Mercurial > hg > CbC > CbC_gcc

comparison gcc/genopinit.c @ 111:04ced10e8804

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
gcc 7
author kono
date Fri, 27 Oct 2017 22:46:09 +0900
parents f6334be47118
children 84e7813d76e9
comparison
equal deleted inserted replaced
68:561a7518be6b 111:04ced10e8804
1 /* Generate code to initialize optabs from machine description. 1 /* Generate code to initialize optabs from machine description.
2 Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2 Copyright (C) 1993-2017 Free Software Foundation, Inc.
3 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2010
4 Free Software Foundation, Inc.
5 3
6 This file is part of GCC. 4 This file is part of GCC.
7 5
8 GCC is free software; you can redistribute it and/or modify it under 6 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 7 the terms of the GNU General Public License as published by the Free
27 #include "rtl.h" 25 #include "rtl.h"
28 #include "errors.h" 26 #include "errors.h"
29 #include "gensupport.h" 27 #include "gensupport.h"
30 28
31 29
32 /* Many parts of GCC use arrays that are indexed by machine mode and 30 #define DEF_RTL_EXPR(V, N, X, C) #V,
33 contain the insn codes for pattern in the MD file that perform a given 31
34 operation on operands of that mode. 32 static const char * const rtx_upname[] = {
35 33 #include "rtl.def"
36 These patterns are present in the MD file with names that contain
37 the mode(s) used and the name of the operation. This program
38 writes a function `init_all_optabs' that initializes the optabs with
39 all the insn codes of the relevant patterns present in the MD file.
40
41 This array contains a list of optabs that need to be initialized. Within
42 each string, the name of the pattern to be matched against is delimited
43 with $( and $). In the string, $a and $b are used to match a short mode
44 name (the part of the mode name not including `mode' and converted to
45 lower-case). When writing out the initializer, the entire string is
46 used. $A and $B are replaced with the full name of the mode; $a and $b
47 are replaced with the short form of the name, as above.
48
49 If $N is present in the pattern, it means the two modes must be consecutive
50 widths in the same mode class (e.g, QImode and HImode). $I means that
51 only full integer modes should be considered for the next mode, and $F
52 means that only float modes should be considered.
53 $P means that both full and partial integer modes should be considered.
54 $Q means that only fixed-point modes should be considered.
55
56 $V means to emit 'v' if the first mode is a MODE_FLOAT mode.
57
58 For some optabs, we store the operation by RTL codes. These are only
59 used for comparisons. In that case, $c and $C are the lower-case and
60 upper-case forms of the comparison, respectively. */
61
62 static const char * const optabs[] =
63 { "set_convert_optab_handler (sext_optab, $B, $A, CODE_FOR_$(extend$a$b2$))",
64 "set_convert_optab_handler (zext_optab, $B, $A, CODE_FOR_$(zero_extend$a$b2$))",
65 "set_convert_optab_handler (sfix_optab, $B, $A, CODE_FOR_$(fix$F$a$I$b2$))",
66 "set_convert_optab_handler (ufix_optab, $B, $A, CODE_FOR_$(fixuns$F$a$b2$))",
67 "set_convert_optab_handler (sfixtrunc_optab, $B, $A, CODE_FOR_$(fix_trunc$F$a$I$b2$))",
68 "set_convert_optab_handler (ufixtrunc_optab, $B, $A, CODE_FOR_$(fixuns_trunc$F$a$I$b2$))",
69 "set_convert_optab_handler (sfloat_optab, $B, $A, CODE_FOR_$(float$I$a$F$b2$))",
70 "set_convert_optab_handler (ufloat_optab, $B, $A, CODE_FOR_$(floatuns$I$a$F$b2$))",
71 "set_convert_optab_handler (trunc_optab, $B, $A, CODE_FOR_$(trunc$a$b2$))",
72 "set_convert_optab_handler (fract_optab, $B, $A, CODE_FOR_$(fract$a$b2$))",
73 "set_convert_optab_handler (fractuns_optab, $B, $A, CODE_FOR_$(fractuns$I$a$Q$b2$))",
74 "set_convert_optab_handler (fractuns_optab, $B, $A, CODE_FOR_$(fractuns$Q$a$I$b2$))",
75 "set_convert_optab_handler (satfract_optab, $B, $A, CODE_FOR_$(satfract$a$Q$b2$))",
76 "set_convert_optab_handler (satfractuns_optab, $B, $A, CODE_FOR_$(satfractuns$I$a$Q$b2$))",
77 "set_optab_handler (add_optab, $A, CODE_FOR_$(add$P$a3$))",
78 "set_optab_handler (addv_optab, $A, CODE_FOR_$(add$F$a3$)),\n\
79 set_optab_handler (add_optab, $A, CODE_FOR_$(add$F$a3$))",
80 "set_optab_handler (addv_optab, $A, CODE_FOR_$(addv$I$a3$))",
81 "set_optab_handler (add_optab, $A, CODE_FOR_$(add$Q$a3$))",
82 "set_optab_handler (ssadd_optab, $A, CODE_FOR_$(ssadd$Q$a3$))",
83 "set_optab_handler (usadd_optab, $A, CODE_FOR_$(usadd$Q$a3$))",
84 "set_optab_handler (sub_optab, $A, CODE_FOR_$(sub$P$a3$))",
85 "set_optab_handler (subv_optab, $A, CODE_FOR_$(sub$F$a3$)),\n\
86 set_optab_handler (sub_optab, $A, CODE_FOR_$(sub$F$a3$))",
87 "set_optab_handler (subv_optab, $A, CODE_FOR_$(subv$I$a3$))",
88 "set_optab_handler (sub_optab, $A, CODE_FOR_$(sub$Q$a3$))",
89 "set_optab_handler (sssub_optab, $A, CODE_FOR_$(sssub$Q$a3$))",
90 "set_optab_handler (ussub_optab, $A, CODE_FOR_$(ussub$Q$a3$))",
91 "set_optab_handler (smul_optab, $A, CODE_FOR_$(mul$Q$a3$))",
92 "set_optab_handler (ssmul_optab, $A, CODE_FOR_$(ssmul$Q$a3$))",
93 "set_optab_handler (usmul_optab, $A, CODE_FOR_$(usmul$Q$a3$))",
94 "set_optab_handler (smul_optab, $A, CODE_FOR_$(mul$P$a3$))",
95 "set_optab_handler (smulv_optab, $A, CODE_FOR_$(mul$F$a3$)),\n\
96 set_optab_handler (smul_optab, $A, CODE_FOR_$(mul$F$a3$))",
97 "set_optab_handler (smulv_optab, $A, CODE_FOR_$(mulv$I$a3$))",
98 "set_optab_handler (umul_highpart_optab, $A, CODE_FOR_$(umul$a3_highpart$))",
99 "set_optab_handler (smul_highpart_optab, $A, CODE_FOR_$(smul$a3_highpart$))",
100 "set_optab_handler (smul_widen_optab, $B, CODE_FOR_$(mul$a$b3$)$N)",
101 "set_optab_handler (umul_widen_optab, $B, CODE_FOR_$(umul$a$b3$)$N)",
102 "set_optab_handler (usmul_widen_optab, $B, CODE_FOR_$(usmul$a$b3$)$N)",
103 "set_optab_handler (smadd_widen_optab, $B, CODE_FOR_$(madd$a$b4$)$N)",
104 "set_optab_handler (umadd_widen_optab, $B, CODE_FOR_$(umadd$a$b4$)$N)",
105 "set_optab_handler (ssmadd_widen_optab, $B, CODE_FOR_$(ssmadd$a$b4$)$N)",
106 "set_optab_handler (usmadd_widen_optab, $B, CODE_FOR_$(usmadd$a$b4$)$N)",
107 "set_optab_handler (smsub_widen_optab, $B, CODE_FOR_$(msub$a$b4$)$N)",
108 "set_optab_handler (umsub_widen_optab, $B, CODE_FOR_$(umsub$a$b4$)$N)",
109 "set_optab_handler (ssmsub_widen_optab, $B, CODE_FOR_$(ssmsub$a$b4$)$N)",
110 "set_optab_handler (usmsub_widen_optab, $B, CODE_FOR_$(usmsub$a$b4$)$N)",
111 "set_optab_handler (sdiv_optab, $A, CODE_FOR_$(div$a3$))",
112 "set_optab_handler (ssdiv_optab, $A, CODE_FOR_$(ssdiv$Q$a3$))",
113 "set_optab_handler (sdivv_optab, $A, CODE_FOR_$(div$V$I$a3$))",
114 "set_optab_handler (udiv_optab, $A, CODE_FOR_$(udiv$I$a3$))",
115 "set_optab_handler (udiv_optab, $A, CODE_FOR_$(udiv$Q$a3$))",
116 "set_optab_handler (usdiv_optab, $A, CODE_FOR_$(usdiv$Q$a3$))",
117 "set_optab_handler (sdivmod_optab, $A, CODE_FOR_$(divmod$a4$))",
118 "set_optab_handler (udivmod_optab, $A, CODE_FOR_$(udivmod$a4$))",
119 "set_optab_handler (smod_optab, $A, CODE_FOR_$(mod$a3$))",
120 "set_optab_handler (umod_optab, $A, CODE_FOR_$(umod$a3$))",
121 "set_optab_handler (fmod_optab, $A, CODE_FOR_$(fmod$a3$))",
122 "set_optab_handler (remainder_optab, $A, CODE_FOR_$(remainder$a3$))",
123 "set_optab_handler (ftrunc_optab, $A, CODE_FOR_$(ftrunc$F$a2$))",
124 "set_optab_handler (and_optab, $A, CODE_FOR_$(and$a3$))",
125 "set_optab_handler (ior_optab, $A, CODE_FOR_$(ior$a3$))",
126 "set_optab_handler (xor_optab, $A, CODE_FOR_$(xor$a3$))",
127 "set_optab_handler (ashl_optab, $A, CODE_FOR_$(ashl$a3$))",
128 "set_optab_handler (ssashl_optab, $A, CODE_FOR_$(ssashl$Q$a3$))",
129 "set_optab_handler (usashl_optab, $A, CODE_FOR_$(usashl$Q$a3$))",
130 "set_optab_handler (ashr_optab, $A, CODE_FOR_$(ashr$a3$))",
131 "set_optab_handler (lshr_optab, $A, CODE_FOR_$(lshr$a3$))",
132 "set_optab_handler (rotl_optab, $A, CODE_FOR_$(rotl$a3$))",
133 "set_optab_handler (rotr_optab, $A, CODE_FOR_$(rotr$a3$))",
134 "set_optab_handler (vashr_optab, $A, CODE_FOR_$(vashr$a3$))",
135 "set_optab_handler (vlshr_optab, $A, CODE_FOR_$(vlshr$a3$))",
136 "set_optab_handler (vashl_optab, $A, CODE_FOR_$(vashl$a3$))",
137 "set_optab_handler (vrotl_optab, $A, CODE_FOR_$(vrotl$a3$))",
138 "set_optab_handler (vrotr_optab, $A, CODE_FOR_$(vrotr$a3$))",
139 "set_optab_handler (smin_optab, $A, CODE_FOR_$(smin$a3$))",
140 "set_optab_handler (smax_optab, $A, CODE_FOR_$(smax$a3$))",
141 "set_optab_handler (umin_optab, $A, CODE_FOR_$(umin$I$a3$))",
142 "set_optab_handler (umax_optab, $A, CODE_FOR_$(umax$I$a3$))",
143 "set_optab_handler (pow_optab, $A, CODE_FOR_$(pow$a3$))",
144 "set_optab_handler (atan2_optab, $A, CODE_FOR_$(atan2$a3$))",
145 "set_optab_handler (neg_optab, $A, CODE_FOR_$(neg$P$a2$))",
146 "set_optab_handler (negv_optab, $A, CODE_FOR_$(neg$F$a2$)),\n\
147 set_optab_handler (neg_optab, $A, CODE_FOR_$(neg$F$a2$))",
148 "set_optab_handler (negv_optab, $A, CODE_FOR_$(negv$I$a2$))",
149 "set_optab_handler (neg_optab, $A, CODE_FOR_$(neg$Q$a2$))",
150 "set_optab_handler (ssneg_optab, $A, CODE_FOR_$(ssneg$Q$a2$))",
151 "set_optab_handler (usneg_optab, $A, CODE_FOR_$(usneg$Q$a2$))",
152 "set_optab_handler (abs_optab, $A, CODE_FOR_$(abs$P$a2$))",
153 "set_optab_handler (absv_optab, $A, CODE_FOR_$(abs$F$a2$)),\n\
154 set_optab_handler (abs_optab, $A, CODE_FOR_$(abs$F$a2$))",
155 "set_optab_handler (absv_optab, $A, CODE_FOR_$(absv$I$a2$))",
156 "set_optab_handler (copysign_optab, $A, CODE_FOR_$(copysign$F$a3$))",
157 "set_optab_handler (signbit_optab, $A, CODE_FOR_$(signbit$F$a2$))",
158 "set_optab_handler (isinf_optab, $A, CODE_FOR_$(isinf$a2$))",
159 "set_optab_handler (sqrt_optab, $A, CODE_FOR_$(sqrt$a2$))",
160 "set_optab_handler (floor_optab, $A, CODE_FOR_$(floor$a2$))",
161 "set_convert_optab_handler (lfloor_optab, $B, $A, CODE_FOR_$(lfloor$F$a$I$b2$))",
162 "set_optab_handler (fma_optab, $A, CODE_FOR_$(fma$a4$))",
163 "set_optab_handler (fms_optab, $A, CODE_FOR_$(fms$a4$))",
164 "set_optab_handler (fnma_optab, $A, CODE_FOR_$(fnma$a4$))",
165 "set_optab_handler (fnms_optab, $A, CODE_FOR_$(fnms$a4$))",
166 "set_optab_handler (ceil_optab, $A, CODE_FOR_$(ceil$a2$))",
167 "set_convert_optab_handler (lceil_optab, $B, $A, CODE_FOR_$(lceil$F$a$I$b2$))",
168 "set_optab_handler (round_optab, $A, CODE_FOR_$(round$a2$))",
169 "set_optab_handler (btrunc_optab, $A, CODE_FOR_$(btrunc$a2$))",
170 "set_optab_handler (nearbyint_optab, $A, CODE_FOR_$(nearbyint$a2$))",
171 "set_optab_handler (rint_optab, $A, CODE_FOR_$(rint$a2$))",
172 "set_convert_optab_handler (lrint_optab, $B, $A, CODE_FOR_$(lrint$F$a$I$b2$))",
173 "set_convert_optab_handler (lround_optab, $B, $A, CODE_FOR_$(lround$F$a$I$b2$))",
174 "set_optab_handler (sincos_optab, $A, CODE_FOR_$(sincos$a3$))",
175 "set_optab_handler (sin_optab, $A, CODE_FOR_$(sin$a2$))",
176 "set_optab_handler (asin_optab, $A, CODE_FOR_$(asin$a2$))",
177 "set_optab_handler (cos_optab, $A, CODE_FOR_$(cos$a2$))",
178 "set_optab_handler (acos_optab, $A, CODE_FOR_$(acos$a2$))",
179 "set_optab_handler (exp_optab, $A, CODE_FOR_$(exp$a2$))",
180 "set_optab_handler (exp10_optab, $A, CODE_FOR_$(exp10$a2$))",
181 "set_optab_handler (exp2_optab, $A, CODE_FOR_$(exp2$a2$))",
182 "set_optab_handler (expm1_optab, $A, CODE_FOR_$(expm1$a2$))",
183 "set_optab_handler (ldexp_optab, $A, CODE_FOR_$(ldexp$a3$))",
184 "set_optab_handler (scalb_optab, $A, CODE_FOR_$(scalb$a3$))",
185 "set_optab_handler (significand_optab, $A, CODE_FOR_$(significand$a2$))",
186 "set_optab_handler (logb_optab, $A, CODE_FOR_$(logb$a2$))",
187 "set_optab_handler (ilogb_optab, $A, CODE_FOR_$(ilogb$a2$))",
188 "set_optab_handler (log_optab, $A, CODE_FOR_$(log$a2$))",
189 "set_optab_handler (log10_optab, $A, CODE_FOR_$(log10$a2$))",
190 "set_optab_handler (log2_optab, $A, CODE_FOR_$(log2$a2$))",
191 "set_optab_handler (log1p_optab, $A, CODE_FOR_$(log1p$a2$))",
192 "set_optab_handler (tan_optab, $A, CODE_FOR_$(tan$a2$))",
193 "set_optab_handler (atan_optab, $A, CODE_FOR_$(atan$a2$))",
194 "set_optab_handler (strlen_optab, $A, CODE_FOR_$(strlen$a$))",
195 "set_optab_handler (one_cmpl_optab, $A, CODE_FOR_$(one_cmpl$a2$))",
196 "set_optab_handler (bswap_optab, $A, CODE_FOR_$(bswap$a2$))",
197 "set_optab_handler (ffs_optab, $A, CODE_FOR_$(ffs$a2$))",
198 "set_optab_handler (clz_optab, $A, CODE_FOR_$(clz$a2$))",
199 "set_optab_handler (ctz_optab, $A, CODE_FOR_$(ctz$a2$))",
200 "set_optab_handler (popcount_optab, $A, CODE_FOR_$(popcount$a2$))",
201 "set_optab_handler (parity_optab, $A, CODE_FOR_$(parity$a2$))",
202 "set_optab_handler (mov_optab, $A, CODE_FOR_$(mov$a$))",
203 "set_optab_handler (movstrict_optab, $A, CODE_FOR_$(movstrict$a$))",
204 "set_optab_handler (movmisalign_optab, $A, CODE_FOR_$(movmisalign$a$))",
205 "set_optab_handler (storent_optab, $A, CODE_FOR_$(storent$a$))",
206 "set_optab_handler (addcc_optab, $A, CODE_FOR_$(add$acc$))",
207 "set_direct_optab_handler (movcc_optab, $A, CODE_FOR_$(mov$acc$))",
208 "set_optab_handler (cbranch_optab, $A, CODE_FOR_$(cbranch$a4$))",
209 "set_optab_handler (cmov_optab, $A, CODE_FOR_$(cmov$a6$))",
210 "set_optab_handler (cstore_optab, $A, CODE_FOR_$(cstore$a4$))",
211 "set_optab_handler (ctrap_optab, $A, CODE_FOR_$(ctrap$a4$))",
212 "set_optab_handler (push_optab, $A, CODE_FOR_$(push$a1$))",
213 "set_direct_optab_handler (reload_in_optab, $A, CODE_FOR_$(reload_in$a$))",
214 "set_direct_optab_handler (reload_out_optab, $A, CODE_FOR_$(reload_out$a$))",
215 "set_direct_optab_handler (movmem_optab, $A, CODE_FOR_$(movmem$a$))",
216 "set_direct_optab_handler (cmpstr_optab, $A, CODE_FOR_$(cmpstr$a$))",
217 "set_direct_optab_handler (cmpstrn_optab, $A, CODE_FOR_$(cmpstrn$a$))",
218 "set_direct_optab_handler (cmpmem_optab, $A, CODE_FOR_$(cmpmem$a$))",
219 "set_direct_optab_handler (setmem_optab, $A, CODE_FOR_$(setmem$a$))",
220 "set_direct_optab_handler (sync_add_optab, $A, CODE_FOR_$(sync_add$I$a$))",
221 "set_direct_optab_handler (sync_sub_optab, $A, CODE_FOR_$(sync_sub$I$a$))",
222 "set_direct_optab_handler (sync_ior_optab, $A, CODE_FOR_$(sync_ior$I$a$))",
223 "set_direct_optab_handler (sync_and_optab, $A, CODE_FOR_$(sync_and$I$a$))",
224 "set_direct_optab_handler (sync_xor_optab, $A, CODE_FOR_$(sync_xor$I$a$))",
225 "set_direct_optab_handler (sync_nand_optab, $A, CODE_FOR_$(sync_nand$I$a$))",
226 "set_direct_optab_handler (sync_old_add_optab, $A, CODE_FOR_$(sync_old_add$I$a$))",
227 "set_direct_optab_handler (sync_old_sub_optab, $A, CODE_FOR_$(sync_old_sub$I$a$))",
228 "set_direct_optab_handler (sync_old_ior_optab, $A, CODE_FOR_$(sync_old_ior$I$a$))",
229 "set_direct_optab_handler (sync_old_and_optab, $A, CODE_FOR_$(sync_old_and$I$a$))",
230 "set_direct_optab_handler (sync_old_xor_optab, $A, CODE_FOR_$(sync_old_xor$I$a$))",
231 "set_direct_optab_handler (sync_old_nand_optab, $A, CODE_FOR_$(sync_old_nand$I$a$))",
232 "set_direct_optab_handler (sync_new_add_optab, $A, CODE_FOR_$(sync_new_add$I$a$))",
233 "set_direct_optab_handler (sync_new_sub_optab, $A, CODE_FOR_$(sync_new_sub$I$a$))",
234 "set_direct_optab_handler (sync_new_ior_optab, $A, CODE_FOR_$(sync_new_ior$I$a$))",
235 "set_direct_optab_handler (sync_new_and_optab, $A, CODE_FOR_$(sync_new_and$I$a$))",
236 "set_direct_optab_handler (sync_new_xor_optab, $A, CODE_FOR_$(sync_new_xor$I$a$))",
237 "set_direct_optab_handler (sync_new_nand_optab, $A, CODE_FOR_$(sync_new_nand$I$a$))",
238 "set_direct_optab_handler (sync_compare_and_swap_optab, $A, CODE_FOR_$(sync_compare_and_swap$I$a$))",
239 "set_direct_optab_handler (sync_lock_test_and_set_optab, $A, CODE_FOR_$(sync_lock_test_and_set$I$a$))",
240 "set_direct_optab_handler (sync_lock_release_optab, $A, CODE_FOR_$(sync_lock_release$I$a$))",
241 "set_optab_handler (vec_set_optab, $A, CODE_FOR_$(vec_set$a$))",
242 "set_optab_handler (vec_extract_optab, $A, CODE_FOR_$(vec_extract$a$))",
243 "set_optab_handler (vec_extract_even_optab, $A, CODE_FOR_$(vec_extract_even$a$))",
244 "set_optab_handler (vec_extract_odd_optab, $A, CODE_FOR_$(vec_extract_odd$a$))",
245 "set_optab_handler (vec_interleave_high_optab, $A, CODE_FOR_$(vec_interleave_high$a$))",
246 "set_optab_handler (vec_interleave_low_optab, $A, CODE_FOR_$(vec_interleave_low$a$))",
247 "set_optab_handler (vec_init_optab, $A, CODE_FOR_$(vec_init$a$))",
248 "set_optab_handler (vec_shl_optab, $A, CODE_FOR_$(vec_shl_$a$))",
249 "set_optab_handler (vec_shr_optab, $A, CODE_FOR_$(vec_shr_$a$))",
250 "set_optab_handler (vec_realign_load_optab, $A, CODE_FOR_$(vec_realign_load_$a$))",
251 "set_direct_optab_handler (vcond_optab, $A, CODE_FOR_$(vcond$a$))",
252 "set_direct_optab_handler (vcondu_optab, $A, CODE_FOR_$(vcondu$a$))",
253 "set_optab_handler (ssum_widen_optab, $A, CODE_FOR_$(widen_ssum$I$a3$))",
254 "set_optab_handler (usum_widen_optab, $A, CODE_FOR_$(widen_usum$I$a3$))",
255 "set_optab_handler (udot_prod_optab, $A, CODE_FOR_$(udot_prod$I$a$))",
256 "set_optab_handler (sdot_prod_optab, $A, CODE_FOR_$(sdot_prod$I$a$))",
257 "set_optab_handler (reduc_smax_optab, $A, CODE_FOR_$(reduc_smax_$a$))",
258 "set_optab_handler (reduc_umax_optab, $A, CODE_FOR_$(reduc_umax_$a$))",
259 "set_optab_handler (reduc_smin_optab, $A, CODE_FOR_$(reduc_smin_$a$))",
260 "set_optab_handler (reduc_umin_optab, $A, CODE_FOR_$(reduc_umin_$a$))",
261 "set_optab_handler (reduc_splus_optab, $A, CODE_FOR_$(reduc_splus_$a$))" ,
262 "set_optab_handler (reduc_uplus_optab, $A, CODE_FOR_$(reduc_uplus_$a$))",
263 "set_optab_handler (vec_widen_umult_hi_optab, $A, CODE_FOR_$(vec_widen_umult_hi_$a$))",
264 "set_optab_handler (vec_widen_umult_lo_optab, $A, CODE_FOR_$(vec_widen_umult_lo_$a$))",
265 "set_optab_handler (vec_widen_smult_hi_optab, $A, CODE_FOR_$(vec_widen_smult_hi_$a$))",
266 "set_optab_handler (vec_widen_smult_lo_optab, $A, CODE_FOR_$(vec_widen_smult_lo_$a$))",
267 "set_optab_handler (vec_unpacks_hi_optab, $A, CODE_FOR_$(vec_unpacks_hi_$a$))",
268 "set_optab_handler (vec_unpacks_lo_optab, $A, CODE_FOR_$(vec_unpacks_lo_$a$))",
269 "set_optab_handler (vec_unpacku_hi_optab, $A, CODE_FOR_$(vec_unpacku_hi_$a$))",
270 "set_optab_handler (vec_unpacku_lo_optab, $A, CODE_FOR_$(vec_unpacku_lo_$a$))",
271 "set_optab_handler (vec_unpacks_float_hi_optab, $A, CODE_FOR_$(vec_unpacks_float_hi_$a$))",
272 "set_optab_handler (vec_unpacks_float_lo_optab, $A, CODE_FOR_$(vec_unpacks_float_lo_$a$))",
273 "set_optab_handler (vec_unpacku_float_hi_optab, $A, CODE_FOR_$(vec_unpacku_float_hi_$a$))",
274 "set_optab_handler (vec_unpacku_float_lo_optab, $A, CODE_FOR_$(vec_unpacku_float_lo_$a$))",
275 "set_optab_handler (vec_pack_trunc_optab, $A, CODE_FOR_$(vec_pack_trunc_$a$))",
276 "set_optab_handler (vec_pack_ssat_optab, $A, CODE_FOR_$(vec_pack_ssat_$a$))",
277 "set_optab_handler (vec_pack_usat_optab, $A, CODE_FOR_$(vec_pack_usat_$a$))",
278 "set_optab_handler (vec_pack_sfix_trunc_optab, $A, CODE_FOR_$(vec_pack_sfix_trunc_$a$))",
279 "set_optab_handler (vec_pack_ufix_trunc_optab, $A, CODE_FOR_$(vec_pack_ufix_trunc_$a$))"
280 }; 34 };
281 35
282 static void gen_insn (rtx); 36 #undef DEF_RTL_EXPR
37
38 /* Vector in which to collect insns that match. */
39 static vec<optab_pattern> patterns;
283 40
284 static void 41 static void
285 gen_insn (rtx insn) 42 gen_insn (md_rtx_info *info)
286 { 43 {
287 const char *name = XSTR (insn, 0); 44 optab_pattern p;
288 int m1 = 0, m2 = 0, op = 0; 45 if (find_optab (&p, XSTR (info->def, 0)))
289 size_t pindex; 46 patterns.safe_push (p);
290 int i; 47 }
291 const char *np, *pp, *p, *q; 48
292 49 static int
293 /* Don't mention instructions whose names are the null string. 50 pattern_cmp (const void *va, const void *vb)
294 They are in the machine description just to be recognized. */ 51 {
295 if (*name == 0) 52 const optab_pattern *a = (const optab_pattern *)va;
296 return; 53 const optab_pattern *b = (const optab_pattern *)vb;
297 54 return a->sort_num - b->sort_num;
298 /* See if NAME matches one of the patterns we have for the optabs we know 55 }
299 about. */ 56
300 57 static int
301 for (pindex = 0; pindex < ARRAY_SIZE (optabs); pindex++) 58 optab_kind_cmp (const void *va, const void *vb)
59 {
60 const optab_def *a = (const optab_def *)va;
61 const optab_def *b = (const optab_def *)vb;
62 int diff = a->kind - b->kind;
63 if (diff == 0)
64 diff = a->op - b->op;
65 return diff;
66 }
67
68 static int
69 optab_rcode_cmp (const void *va, const void *vb)
70 {
71 const optab_def *a = (const optab_def *)va;
72 const optab_def *b = (const optab_def *)vb;
73 return a->rcode - b->rcode;
74 }
75
76 static const char *header_file_name = "init-opinit.h";
77 static const char *source_file_name = "init-opinit.c";
78
79 static bool
80 handle_arg (const char *arg)
81 {
82 switch (arg[1])
302 { 83 {
303 int force_float = 0, force_int = 0, force_partial_int = 0; 84 case 'h':
304 int force_fixed = 0; 85 header_file_name = &arg[2];
305 int force_consec = 0; 86 return true;
306 int matches = 1; 87 case 'c':
307 88 source_file_name = &arg[2];
308 for (pp = optabs[pindex]; pp[0] != '$' || pp[1] != '('; pp++) 89 return true;
309 ; 90 default:
310 91 return false;
311 for (pp += 2, np = name; matches && ! (pp[0] == '$' && pp[1] == ')'); 92 }
312 pp++) 93 }
313 { 94
314 if (*pp != '$') 95 static FILE *
315 { 96 open_outfile (const char *file_name)
316 if (*pp != *np++) 97 {
317 break; 98 FILE *f = fopen (file_name, "w");
318 } 99 if (!f)
319 else 100 fatal ("cannot open file %s: %s", file_name, xstrerror (errno));
320 switch (*++pp) 101 fprintf (f,
321 { 102 "/* Generated automatically by the program `genopinit'\n"
322 case 'N': 103 " from the machine description file `md'. */\n\n");
323 force_consec = 1; 104 return f;
324 break; 105 }
325 case 'I': 106
326 force_int = 1; 107 int
327 break; 108 main (int argc, const char **argv)
328 case 'P': 109 {
329 force_partial_int = 1; 110 FILE *h_file, *s_file;
330 break; 111 unsigned int i, j, n, last_kind[5];
331 case 'F': 112 optab_pattern *p;
332 force_float = 1; 113
333 break; 114 progname = "genopinit";
334 case 'Q': 115
335 force_fixed = 1; 116 if (NUM_OPTABS > 0xffff || MAX_MACHINE_MODE >= 0xff)
336 break; 117 fatal ("genopinit range assumptions invalid");
337 case 'V': 118
338 break; 119 if (!init_rtx_reader_args_cb (argc, argv, handle_arg))
339 case 'c': 120 return (FATAL_EXIT_CODE);
340 for (op = 0; op < NUM_RTX_CODE; op++) 121
341 { 122 h_file = open_outfile (header_file_name);
342 for (p = GET_RTX_NAME(op), q = np; *p; p++, q++) 123 s_file = open_outfile (source_file_name);
343 if (*p != *q) 124
344 break; 125 /* Read the machine description. */
345 126 md_rtx_info info;
346 /* We have to be concerned about matching "gt" and 127 while (read_md_rtx (&info))
347 missing "gtu", e.g., so verify we have reached the 128 switch (GET_CODE (info.def))
348 end of thing we are to match. */ 129 {
349 if (*p == 0 && *q == 0 130 case DEFINE_INSN:
350 && (GET_RTX_CLASS (op) == RTX_COMPARE 131 case DEFINE_EXPAND:
351 || GET_RTX_CLASS (op) == RTX_COMM_COMPARE)) 132 gen_insn (&info);
352 break;
353 }
354
355 if (op == NUM_RTX_CODE)
356 matches = 0;
357 else
358 np += strlen (GET_RTX_NAME(op));
359 break;
360 case 'a':
361 case 'b':
362 /* This loop will stop at the first prefix match, so
363 look through the modes in reverse order, in case
364 there are extra CC modes and CC is a prefix of the
365 CC modes (as it should be). */
366 for (i = (MAX_MACHINE_MODE) - 1; i >= 0; i--)
367 {
368 for (p = GET_MODE_NAME(i), q = np; *p; p++, q++)
369 if (TOLOWER (*p) != *q)
370 break;
371
372 if (*p == 0
373 && (! force_int || mode_class[i] == MODE_INT
374 || mode_class[i] == MODE_VECTOR_INT)
375 && (! force_partial_int
376 || mode_class[i] == MODE_INT
377 || mode_class[i] == MODE_PARTIAL_INT
378 || mode_class[i] == MODE_VECTOR_INT)
379 && (! force_float
380 || mode_class[i] == MODE_FLOAT
381 || mode_class[i] == MODE_DECIMAL_FLOAT
382 || mode_class[i] == MODE_COMPLEX_FLOAT
383 || mode_class[i] == MODE_VECTOR_FLOAT)
384 && (! force_fixed
385 || mode_class[i] == MODE_FRACT
386 || mode_class[i] == MODE_UFRACT
387 || mode_class[i] == MODE_ACCUM
388 || mode_class[i] == MODE_UACCUM
389 || mode_class[i] == MODE_VECTOR_FRACT
390 || mode_class[i] == MODE_VECTOR_UFRACT
391 || mode_class[i] == MODE_VECTOR_ACCUM
392 || mode_class[i] == MODE_VECTOR_UACCUM))
393 break;
394 }
395
396 if (i < 0)
397 matches = 0;
398 else if (*pp == 'a')
399 m1 = i, np += strlen (GET_MODE_NAME(i));
400 else
401 m2 = i, np += strlen (GET_MODE_NAME(i));
402
403 force_int = force_partial_int = force_float = force_fixed = 0;
404 break;
405
406 default:
407 gcc_unreachable ();
408 }
409 }
410
411 if (matches && pp[0] == '$' && pp[1] == ')'
412 && *np == 0
413 && (! force_consec || (int) GET_MODE_WIDER_MODE(m1) == m2))
414 break; 133 break;
134
135 default:
136 break;
137 }
138
139 /* Sort the collected patterns. */
140 patterns.qsort (pattern_cmp);
141
142 /* Now that we've handled the "extra" patterns, eliminate them from
143 the optabs array. That way they don't get in the way below. */
144 n = num_optabs;
145 for (i = 0; i < n; )
146 if (optabs[i].base == NULL)
147 optabs[i] = optabs[--n];
148 else
149 ++i;
150
151 /* Sort the (real) optabs. Better than forcing the optabs.def file to
152 remain sorted by kind. We also scrogged any real ordering with the
153 purging of the X patterns above. */
154 qsort (optabs, n, sizeof (optab_def), optab_kind_cmp);
155
156 fprintf (h_file, "#ifndef GCC_INSN_OPINIT_H\n");
157 fprintf (h_file, "#define GCC_INSN_OPINIT_H 1\n");
158
159 /* Emit the optab enumeration for the header file. */
160 fprintf (h_file, "enum optab_tag {\n");
161 for (i = j = 0; i < n; ++i)
162 {
163 optabs[i].op = i;
164 fprintf (h_file, " %s,\n", optabs[i].name);
165 if (optabs[i].kind != j)
166 last_kind[j++] = i - 1;
415 } 167 }
416 168 fprintf (h_file, " FIRST_CONV_OPTAB = %s,\n", optabs[last_kind[0]+1].name);
417 if (pindex == ARRAY_SIZE (optabs)) 169 fprintf (h_file, " LAST_CONVLIB_OPTAB = %s,\n", optabs[last_kind[1]].name);
418 return; 170 fprintf (h_file, " LAST_CONV_OPTAB = %s,\n", optabs[last_kind[2]].name);
419 171 fprintf (h_file, " FIRST_NORM_OPTAB = %s,\n", optabs[last_kind[2]+1].name);
420 /* We found a match. If this pattern is only conditionally present, 172 fprintf (h_file, " LAST_NORMLIB_OPTAB = %s,\n", optabs[last_kind[3]].name);
421 write out the "if" and two extra blanks. */ 173 fprintf (h_file, " LAST_NORM_OPTAB = %s\n", optabs[i-1].name);
422 174 fprintf (h_file, "};\n\n");
423 if (*XSTR (insn, 2) != 0) 175
424 printf (" if (HAVE_%s)\n ", name); 176 fprintf (h_file, "#define NUM_OPTABS %u\n", n);
425 177 fprintf (h_file, "#define NUM_CONVLIB_OPTABS %u\n",
426 printf (" "); 178 last_kind[1] - last_kind[0]);
427 179 fprintf (h_file, "#define NUM_NORMLIB_OPTABS %u\n",
428 /* Now write out the initialization, making all required substitutions. */ 180 last_kind[3] - last_kind[2]);
429 for (pp = optabs[pindex]; *pp; pp++) 181 fprintf (h_file, "#define NUM_OPTAB_PATTERNS %u\n",
182 (unsigned) patterns.length ());
183
184 fprintf (h_file,
185 "typedef enum optab_tag optab;\n"
186 "typedef enum optab_tag convert_optab;\n"
187 "typedef enum optab_tag direct_optab;\n"
188 "\n"
189 "struct optab_libcall_d\n"
190 "{\n"
191 " char libcall_suffix;\n"
192 " const char *libcall_basename;\n"
193 " void (*libcall_gen) (optab, const char *name,\n"
194 " char suffix, machine_mode);\n"
195 "};\n"
196 "\n"
197 "struct convert_optab_libcall_d\n"
198 "{\n"
199 " const char *libcall_basename;\n"
200 " void (*libcall_gen) (convert_optab, const char *name,\n"
201 " machine_mode, machine_mode);\n"
202 "};\n"
203 "\n"
204 "/* Given an enum insn_code, access the function to construct\n"
205 " the body of that kind of insn. */\n"
206 "#define GEN_FCN(CODE) (insn_data[CODE].genfun)\n"
207 "\n"
208 "#ifdef NUM_RTX_CODE\n"
209 "/* Contains the optab used for each rtx code, and vice-versa. */\n"
210 "extern const optab code_to_optab_[NUM_RTX_CODE];\n"
211 "extern const enum rtx_code optab_to_code_[NUM_OPTABS];\n"
212 "\n"
213 "static inline optab\n"
214 "code_to_optab (enum rtx_code code)\n"
215 "{\n"
216 " return code_to_optab_[code];\n"
217 "}\n"
218 "\n"
219 "static inline enum rtx_code\n"
220 "optab_to_code (optab op)\n"
221 "{\n"
222 " return optab_to_code_[op];\n"
223 "}\n"
224 "#endif\n"
225 "\n"
226 "extern const struct convert_optab_libcall_d convlib_def[NUM_CONVLIB_OPTABS];\n"
227 "extern const struct optab_libcall_d normlib_def[NUM_NORMLIB_OPTABS];\n"
228 "\n"
229 "/* Returns the active icode for the given (encoded) optab. */\n"
230 "extern enum insn_code raw_optab_handler (unsigned);\n"
231 "extern bool swap_optab_enable (optab, machine_mode, bool);\n"
232 "\n"
233 "/* Target-dependent globals. */\n"
234 "struct target_optabs {\n"
235 " /* Patterns that are used by optabs that are enabled for this target. */\n"
236 " bool pat_enable[NUM_OPTAB_PATTERNS];\n"
237 "};\n"
238 "extern void init_all_optabs (struct target_optabs *);\n"
239 "\n"
240 "extern struct target_optabs default_target_optabs;\n"
241 "extern struct target_optabs *this_fn_optabs;\n"
242 "#if SWITCHABLE_TARGET\n"
243 "extern struct target_optabs *this_target_optabs;\n"
244 "#else\n"
245 "#define this_target_optabs (&default_target_optabs)\n"
246 "#endif\n");
247
248 fprintf (s_file,
249 "#include \"config.h\"\n"
250 "#include \"system.h\"\n"
251 "#include \"coretypes.h\"\n"
252 "#include \"backend.h\"\n"
253 "#include \"predict.h\"\n"
254 "#include \"tree.h\"\n"
255 "#include \"rtl.h\"\n"
256 "#include \"alias.h\"\n"
257 "#include \"varasm.h\"\n"
258 "#include \"stor-layout.h\"\n"
259 "#include \"calls.h\"\n"
260 "#include \"memmodel.h\"\n"
261 "#include \"tm_p.h\"\n"
262 "#include \"flags.h\"\n"
263 "#include \"insn-config.h\"\n"
264 "#include \"expmed.h\"\n"
265 "#include \"dojump.h\"\n"
266 "#include \"explow.h\"\n"
267 "#include \"emit-rtl.h\"\n"
268 "#include \"stmt.h\"\n"
269 "#include \"expr.h\"\n"
270 "#include \"insn-codes.h\"\n"
271 "#include \"optabs.h\"\n"
272 "\n"
273 "struct optab_pat {\n"
274 " unsigned scode;\n"
275 " enum insn_code icode;\n"
276 "};\n\n");
277
278 fprintf (s_file,
279 "static const struct optab_pat pats[NUM_OPTAB_PATTERNS] = {\n");
280 for (i = 0; patterns.iterate (i, &p); ++i)
281 fprintf (s_file, " { %#08x, CODE_FOR_%s },\n", p->sort_num, p->name);
282 fprintf (s_file, "};\n\n");
283
284 fprintf (s_file, "void\ninit_all_optabs (struct target_optabs *optabs)\n{\n");
285 fprintf (s_file, " bool *ena = optabs->pat_enable;\n");
286 for (i = 0; patterns.iterate (i, &p); ++i)
287 fprintf (s_file, " ena[%u] = HAVE_%s;\n", i, p->name);
288 fprintf (s_file, "}\n\n");
289
290 /* Perform a binary search on a pre-encoded optab+mode*2. */
291 /* ??? Perhaps even better to generate a minimal perfect hash.
292 Using gperf directly is awkward since it's so geared to working
293 with strings. Plus we have no visibility into the ordering of
294 the hash entries, which complicates the pat_enable array. */
295 fprintf (s_file,
296 "static int\n"
297 "lookup_handler (unsigned scode)\n"
298 "{\n"
299 " int l = 0, h = ARRAY_SIZE (pats), m;\n"
300 " while (h > l)\n"
301 " {\n"
302 " m = (h + l) / 2;\n"
303 " if (scode == pats[m].scode)\n"
304 " return m;\n"
305 " else if (scode < pats[m].scode)\n"
306 " h = m;\n"
307 " else\n"
308 " l = m + 1;\n"
309 " }\n"
310 " return -1;\n"
311 "}\n\n");
312
313 fprintf (s_file,
314 "enum insn_code\n"
315 "raw_optab_handler (unsigned scode)\n"
316 "{\n"
317 " int i = lookup_handler (scode);\n"
318 " return (i >= 0 && this_fn_optabs->pat_enable[i]\n"
319 " ? pats[i].icode : CODE_FOR_nothing);\n"
320 "}\n\n");
321
322 fprintf (s_file,
323 "bool\n"
324 "swap_optab_enable (optab op, machine_mode m, bool set)\n"
325 "{\n"
326 " unsigned scode = (op << 16) | m;\n"
327 " int i = lookup_handler (scode);\n"
328 " if (i >= 0)\n"
329 " {\n"
330 " bool ret = this_fn_optabs->pat_enable[i];\n"
331 " this_fn_optabs->pat_enable[i] = set;\n"
332 " return ret;\n"
333 " }\n"
334 " else\n"
335 " {\n"
336 " gcc_assert (!set);\n"
337 " return false;\n"
338 " }\n"
339 "}\n\n");
340
341 /* C++ (even G++) does not support (non-trivial) designated initializers.
342 To work around that, generate these arrays programatically rather than
343 by our traditional multiple inclusion of def files. */
344
345 fprintf (s_file,
346 "const struct convert_optab_libcall_d "
347 "convlib_def[NUM_CONVLIB_OPTABS] = {\n");
348 for (i = last_kind[0] + 1; i <= last_kind[1]; ++i)
349 fprintf (s_file, " { %s, %s },\n", optabs[i].base, optabs[i].libcall);
350 fprintf (s_file, "};\n\n");
351
352 fprintf (s_file,
353 "const struct optab_libcall_d "
354 "normlib_def[NUM_NORMLIB_OPTABS] = {\n");
355 for (i = last_kind[2] + 1; i <= last_kind[3]; ++i)
356 fprintf (s_file, " { %s, %s, %s },\n",
357 optabs[i].suffix, optabs[i].base, optabs[i].libcall);
358 fprintf (s_file, "};\n\n");
359
360 fprintf (s_file, "enum rtx_code const optab_to_code_[NUM_OPTABS] = {\n");
361 for (i = 0; i < n; ++i)
362 fprintf (s_file, " %s,\n", rtx_upname[optabs[i].fcode]);
363 fprintf (s_file, "};\n\n");
364
365 qsort (optabs, n, sizeof (optab_def), optab_rcode_cmp);
366
367 fprintf (s_file, "const optab code_to_optab_[NUM_RTX_CODE] = {\n");
368 for (j = 0; optabs[j].rcode == UNKNOWN; ++j)
369 continue;
370 for (i = 0; i < NON_GENERATOR_NUM_RTX_CODE; ++i)
430 { 371 {
431 if (*pp != '$') 372 if (j < n && optabs[j].rcode == i)
432 putchar (*pp); 373 fprintf (s_file, " %s,\n", optabs[j++].name);
433 else 374 else
434 switch (*++pp) 375 fprintf (s_file, " unknown_optab,\n");
435 {
436 case '(': case ')':
437 case 'I': case 'F': case 'N':
438 break;
439 case 'V':
440 if (SCALAR_FLOAT_MODE_P (m1))
441 printf ("v");
442 break;
443 case 'a':
444 for (np = GET_MODE_NAME(m1); *np; np++)
445 putchar (TOLOWER (*np));
446 break;
447 case 'b':
448 for (np = GET_MODE_NAME(m2); *np; np++)
449 putchar (TOLOWER (*np));
450 break;
451 case 'A':
452 printf ("%smode", GET_MODE_NAME(m1));
453 break;
454 case 'B':
455 printf ("%smode", GET_MODE_NAME(m2));
456 break;
457 case 'c':
458 printf ("%s", GET_RTX_NAME(op));
459 break;
460 case 'C':
461 for (np = GET_RTX_NAME(op); *np; np++)
462 putchar (TOUPPER (*np));
463 break;
464 }
465 } 376 }
466 377 fprintf (s_file, "};\n\n");
467 printf (";\n"); 378
468 } 379 fprintf (h_file, "#endif\n");
469 380 return (fclose (h_file) == 0 && fclose (s_file) == 0
470 extern int main (int, char **); 381 ? SUCCESS_EXIT_CODE : FATAL_EXIT_CODE);
471 382 }
472 int
473 main (int argc, char **argv)
474 {
475 rtx desc;
476
477 progname = "genopinit";
478
479 if (!init_rtx_reader_args (argc, argv))
480 return (FATAL_EXIT_CODE);
481
482 printf ("/* Generated automatically by the program `genopinit'\n\
483 from the machine description file `md'. */\n\n");
484
485 printf ("#include \"config.h\"\n");
486 printf ("#include \"system.h\"\n");
487 printf ("#include \"coretypes.h\"\n");
488 printf ("#include \"tm.h\"\n");
489 printf ("#include \"rtl.h\"\n");
490 printf ("#include \"tm_p.h\"\n");
491 printf ("#include \"flags.h\"\n");
492 printf ("#include \"insn-config.h\"\n");
493 printf ("#include \"recog.h\"\n");
494 printf ("#include \"expr.h\"\n");
495 printf ("#include \"optabs.h\"\n");
496 printf ("#include \"reload.h\"\n\n");
497
498 printf ("void\ninit_all_optabs (void)\n{\n");
499
500 puts ("\
501 #ifdef FIXUNS_TRUNC_LIKE_FIX_TRUNC\n\
502 int i, j;\n\
503 #endif\n");
504
505 /* Read the machine description. */
506
507 while (1)
508 {
509 int line_no, insn_code_number = 0;
510
511 desc = read_md_rtx (&line_no, &insn_code_number);
512 if (desc == NULL)
513 break;
514
515 if (GET_CODE (desc) == DEFINE_INSN || GET_CODE (desc) == DEFINE_EXPAND)
516 gen_insn (desc);
517 }
518
519 puts ("\
520 \n\
521 #ifdef FIXUNS_TRUNC_LIKE_FIX_TRUNC\n\
522 /* This flag says the same insns that convert to a signed fixnum\n\
523 also convert validly to an unsigned one. */\n\
524 for (i = 0; i < NUM_MACHINE_MODES; i++)\n\
525 for (j = 0; j < NUM_MACHINE_MODES; j++)\n\
526 set_convert_optab_handler\n\
527 (ufixtrunc_optab, (enum machine_mode) i, (enum machine_mode) j,\n\
528 convert_optab_handler (sfixtrunc_optab, (enum machine_mode) i,\n\
529 (enum machine_mode) j));\n\
530 #endif\n\
531 }");
532
533 fflush (stdout);
534 return (ferror (stdout) != 0 ? FATAL_EXIT_CODE : SUCCESS_EXIT_CODE);
535 }