1 /* Generate code to initialize optabs from machine description. 2 Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 3 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 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 23 #include "bconfig.h" 24 #include "system.h" 25 #include "coretypes.h" 26 #include "tm.h" 27 #include "rtl.h" 28 #include "errors.h" 29 #include "gensupport.h" 30 31 32 /* Many parts of GCC use arrays that are indexed by machine mode and 33 contain the insn codes for pattern in the MD file that perform a given 34 operation on operands of that mode. 35 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 { "convert_optab_handler (sext_optab, $B, $A)->insn_code = CODE_FOR_$(extend$a$b2$)", 64 "convert_optab_handler (zext_optab, $B, $A)->insn_code = CODE_FOR_$(zero_extend$a$b2$)", 65 "convert_optab_handler (sfix_optab, $B, $A)->insn_code = CODE_FOR_$(fix$F$a$I$b2$)", 66 "convert_optab_handler (ufix_optab, $B, $A)->insn_code = CODE_FOR_$(fixuns$F$a$b2$)", 67 "convert_optab_handler (sfixtrunc_optab, $B, $A)->insn_code = CODE_FOR_$(fix_trunc$F$a$I$b2$)", 68 "convert_optab_handler (ufixtrunc_optab, $B, $A)->insn_code = CODE_FOR_$(fixuns_trunc$F$a$I$b2$)", 69 "convert_optab_handler (sfloat_optab, $B, $A)->insn_code = CODE_FOR_$(float$I$a$F$b2$)", 70 "convert_optab_handler (ufloat_optab, $B, $A)->insn_code = CODE_FOR_$(floatuns$I$a$F$b2$)", 71 "convert_optab_handler (trunc_optab, $B, $A)->insn_code = CODE_FOR_$(trunc$a$b2$)", 72 "convert_optab_handler (fract_optab, $B, $A)->insn_code = CODE_FOR_$(fract$a$b2$)", 73 "convert_optab_handler (fractuns_optab, $B, $A)->insn_code = CODE_FOR_$(fractuns$I$a$Q$b2$)", 74 "convert_optab_handler (fractuns_optab, $B, $A)->insn_code = CODE_FOR_$(fractuns$Q$a$I$b2$)", 75 "convert_optab_handler (satfract_optab, $B, $A)->insn_code = CODE_FOR_$(satfract$a$Q$b2$)", 76 "convert_optab_handler (satfractuns_optab, $B, $A)->insn_code = CODE_FOR_$(satfractuns$I$a$Q$b2$)", 77 "optab_handler (add_optab, $A)->insn_code = CODE_FOR_$(add$P$a3$)", 78 "optab_handler (addv_optab, $A)->insn_code =\n\ 79 optab_handler (add_optab, $A)->insn_code = CODE_FOR_$(add$F$a3$)", 80 "optab_handler (addv_optab, $A)->insn_code = CODE_FOR_$(addv$I$a3$)", 81 "optab_handler (add_optab, $A)->insn_code = CODE_FOR_$(add$Q$a3$)", 82 "optab_handler (ssadd_optab, $A)->insn_code = CODE_FOR_$(ssadd$Q$a3$)", 83 "optab_handler (usadd_optab, $A)->insn_code = CODE_FOR_$(usadd$Q$a3$)", 84 "optab_handler (sub_optab, $A)->insn_code = CODE_FOR_$(sub$P$a3$)", 85 "optab_handler (subv_optab, $A)->insn_code =\n\ 86 optab_handler (sub_optab, $A)->insn_code = CODE_FOR_$(sub$F$a3$)", 87 "optab_handler (subv_optab, $A)->insn_code = CODE_FOR_$(subv$I$a3$)", 88 "optab_handler (sub_optab, $A)->insn_code = CODE_FOR_$(sub$Q$a3$)", 89 "optab_handler (sssub_optab, $A)->insn_code = CODE_FOR_$(sssub$Q$a3$)", 90 "optab_handler (ussub_optab, $A)->insn_code = CODE_FOR_$(ussub$Q$a3$)", 91 "optab_handler (smul_optab, $A)->insn_code = CODE_FOR_$(mul$Q$a3$)", 92 "optab_handler (ssmul_optab, $A)->insn_code = CODE_FOR_$(ssmul$Q$a3$)", 93 "optab_handler (usmul_optab, $A)->insn_code = CODE_FOR_$(usmul$Q$a3$)", 94 "optab_handler (smul_optab, $A)->insn_code = CODE_FOR_$(mul$P$a3$)", 95 "optab_handler (smulv_optab, $A)->insn_code =\n\ 96 optab_handler (smul_optab, $A)->insn_code = CODE_FOR_$(mul$F$a3$)", 97 "optab_handler (smulv_optab, $A)->insn_code = CODE_FOR_$(mulv$I$a3$)", 98 "optab_handler (umul_highpart_optab, $A)->insn_code = CODE_FOR_$(umul$a3_highpart$)", 99 "optab_handler (smul_highpart_optab, $A)->insn_code = CODE_FOR_$(smul$a3_highpart$)", 100 "optab_handler (smul_widen_optab, $B)->insn_code = CODE_FOR_$(mul$a$b3$)$N", 101 "optab_handler (umul_widen_optab, $B)->insn_code = CODE_FOR_$(umul$a$b3$)$N", 102 "optab_handler (usmul_widen_optab, $B)->insn_code = CODE_FOR_$(usmul$a$b3$)$N", 103 "optab_handler (smadd_widen_optab, $B)->insn_code = CODE_FOR_$(madd$a$b4$)$N", 104 "optab_handler (umadd_widen_optab, $B)->insn_code = CODE_FOR_$(umadd$a$b4$)$N", 105 "optab_handler (ssmadd_widen_optab, $B)->insn_code = CODE_FOR_$(ssmadd$a$b4$)$N", 106 "optab_handler (usmadd_widen_optab, $B)->insn_code = CODE_FOR_$(usmadd$a$b4$)$N", 107 "optab_handler (smsub_widen_optab, $B)->insn_code = CODE_FOR_$(msub$a$b4$)$N", 108 "optab_handler (umsub_widen_optab, $B)->insn_code = CODE_FOR_$(umsub$a$b4$)$N", 109 "optab_handler (ssmsub_widen_optab, $B)->insn_code = CODE_FOR_$(ssmsub$a$b4$)$N", 110 "optab_handler (usmsub_widen_optab, $B)->insn_code = CODE_FOR_$(usmsub$a$b4$)$N", 111 "optab_handler (sdiv_optab, $A)->insn_code = CODE_FOR_$(div$a3$)", 112 "optab_handler (ssdiv_optab, $A)->insn_code = CODE_FOR_$(ssdiv$Q$a3$)", 113 "optab_handler (sdivv_optab, $A)->insn_code = CODE_FOR_$(div$V$I$a3$)", 114 "optab_handler (udiv_optab, $A)->insn_code = CODE_FOR_$(udiv$I$a3$)", 115 "optab_handler (udiv_optab, $A)->insn_code = CODE_FOR_$(udiv$Q$a3$)", 116 "optab_handler (usdiv_optab, $A)->insn_code = CODE_FOR_$(usdiv$Q$a3$)", 117 "optab_handler (sdivmod_optab, $A)->insn_code = CODE_FOR_$(divmod$a4$)", 118 "optab_handler (udivmod_optab, $A)->insn_code = CODE_FOR_$(udivmod$a4$)", 119 "optab_handler (smod_optab, $A)->insn_code = CODE_FOR_$(mod$a3$)", 120 "optab_handler (umod_optab, $A)->insn_code = CODE_FOR_$(umod$a3$)", 121 "optab_handler (fmod_optab, $A)->insn_code = CODE_FOR_$(fmod$a3$)", 122 "optab_handler (remainder_optab, $A)->insn_code = CODE_FOR_$(remainder$a3$)", 123 "optab_handler (ftrunc_optab, $A)->insn_code = CODE_FOR_$(ftrunc$F$a2$)", 124 "optab_handler (and_optab, $A)->insn_code = CODE_FOR_$(and$a3$)", 125 "optab_handler (ior_optab, $A)->insn_code = CODE_FOR_$(ior$a3$)", 126 "optab_handler (xor_optab, $A)->insn_code = CODE_FOR_$(xor$a3$)", 127 "optab_handler (ashl_optab, $A)->insn_code = CODE_FOR_$(ashl$a3$)", 128 "optab_handler (ssashl_optab, $A)->insn_code = CODE_FOR_$(ssashl$Q$a3$)", 129 "optab_handler (usashl_optab, $A)->insn_code = CODE_FOR_$(usashl$Q$a3$)", 130 "optab_handler (ashr_optab, $A)->insn_code = CODE_FOR_$(ashr$a3$)", 131 "optab_handler (lshr_optab, $A)->insn_code = CODE_FOR_$(lshr$a3$)", 132 "optab_handler (rotl_optab, $A)->insn_code = CODE_FOR_$(rotl$a3$)", 133 "optab_handler (rotr_optab, $A)->insn_code = CODE_FOR_$(rotr$a3$)", 134 "optab_handler (vashr_optab, $A)->insn_code = CODE_FOR_$(vashr$a3$)", 135 "optab_handler (vlshr_optab, $A)->insn_code = CODE_FOR_$(vlshr$a3$)", 136 "optab_handler (vashl_optab, $A)->insn_code = CODE_FOR_$(vashl$a3$)", 137 "optab_handler (vrotl_optab, $A)->insn_code = CODE_FOR_$(vrotl$a3$)", 138 "optab_handler (vrotr_optab, $A)->insn_code = CODE_FOR_$(vrotr$a3$)", 139 "optab_handler (smin_optab, $A)->insn_code = CODE_FOR_$(smin$a3$)", 140 "optab_handler (smax_optab, $A)->insn_code = CODE_FOR_$(smax$a3$)", 141 "optab_handler (umin_optab, $A)->insn_code = CODE_FOR_$(umin$I$a3$)", 142 "optab_handler (umax_optab, $A)->insn_code = CODE_FOR_$(umax$I$a3$)", 143 "optab_handler (pow_optab, $A)->insn_code = CODE_FOR_$(pow$a3$)", 144 "optab_handler (atan2_optab, $A)->insn_code = CODE_FOR_$(atan2$a3$)", 145 "optab_handler (neg_optab, $A)->insn_code = CODE_FOR_$(neg$P$a2$)", 146 "optab_handler (negv_optab, $A)->insn_code =\n\ 147 optab_handler (neg_optab, $A)->insn_code = CODE_FOR_$(neg$F$a2$)", 148 "optab_handler (negv_optab, $A)->insn_code = CODE_FOR_$(negv$I$a2$)", 149 "optab_handler (neg_optab, $A)->insn_code = CODE_FOR_$(neg$Q$a2$)", 150 "optab_handler (ssneg_optab, $A)->insn_code = CODE_FOR_$(ssneg$Q$a2$)", 151 "optab_handler (usneg_optab, $A)->insn_code = CODE_FOR_$(usneg$Q$a2$)", 152 "optab_handler (abs_optab, $A)->insn_code = CODE_FOR_$(abs$P$a2$)", 153 "optab_handler (absv_optab, $A)->insn_code =\n\ 154 optab_handler (abs_optab, $A)->insn_code = CODE_FOR_$(abs$F$a2$)", 155 "optab_handler (absv_optab, $A)->insn_code = CODE_FOR_$(absv$I$a2$)", 156 "optab_handler (copysign_optab, $A)->insn_code = CODE_FOR_$(copysign$F$a3$)", 157 "optab_handler (signbit_optab, $A)->insn_code = CODE_FOR_$(signbit$F$a2$)", 158 "optab_handler (isinf_optab, $A)->insn_code = CODE_FOR_$(isinf$a2$)", 159 "optab_handler (sqrt_optab, $A)->insn_code = CODE_FOR_$(sqrt$a2$)", 160 "optab_handler (floor_optab, $A)->insn_code = CODE_FOR_$(floor$a2$)", 161 "convert_optab_handler (lfloor_optab, $B, $A)->insn_code = CODE_FOR_$(lfloor$F$a$I$b2$)", 162 "optab_handler (ceil_optab, $A)->insn_code = CODE_FOR_$(ceil$a2$)", 163 "convert_optab_handler (lceil_optab, $B, $A)->insn_code = CODE_FOR_$(lceil$F$a$I$b2$)", 164 "optab_handler (round_optab, $A)->insn_code = CODE_FOR_$(round$a2$)", 165 "optab_handler (btrunc_optab, $A)->insn_code = CODE_FOR_$(btrunc$a2$)", 166 "optab_handler (nearbyint_optab, $A)->insn_code = CODE_FOR_$(nearbyint$a2$)", 167 "optab_handler (rint_optab, $A)->insn_code = CODE_FOR_$(rint$a2$)", 168 "convert_optab_handler (lrint_optab, $B, $A)->insn_code = CODE_FOR_$(lrint$F$a$I$b2$)", 169 "convert_optab_handler (lround_optab, $B, $A)->insn_code = CODE_FOR_$(lround$F$a$I$b2$)", 170 "optab_handler (sincos_optab, $A)->insn_code = CODE_FOR_$(sincos$a3$)", 171 "optab_handler (sin_optab, $A)->insn_code = CODE_FOR_$(sin$a2$)", 172 "optab_handler (asin_optab, $A)->insn_code = CODE_FOR_$(asin$a2$)", 173 "optab_handler (cos_optab, $A)->insn_code = CODE_FOR_$(cos$a2$)", 174 "optab_handler (acos_optab, $A)->insn_code = CODE_FOR_$(acos$a2$)", 175 "optab_handler (exp_optab, $A)->insn_code = CODE_FOR_$(exp$a2$)", 176 "optab_handler (exp10_optab, $A)->insn_code = CODE_FOR_$(exp10$a2$)", 177 "optab_handler (exp2_optab, $A)->insn_code = CODE_FOR_$(exp2$a2$)", 178 "optab_handler (expm1_optab, $A)->insn_code = CODE_FOR_$(expm1$a2$)", 179 "optab_handler (ldexp_optab, $A)->insn_code = CODE_FOR_$(ldexp$a3$)", 180 "optab_handler (scalb_optab, $A)->insn_code = CODE_FOR_$(scalb$a3$)", 181 "optab_handler (significand_optab, $A)->insn_code = CODE_FOR_$(significand$a2$)", 182 "optab_handler (logb_optab, $A)->insn_code = CODE_FOR_$(logb$a2$)", 183 "optab_handler (ilogb_optab, $A)->insn_code = CODE_FOR_$(ilogb$a2$)", 184 "optab_handler (log_optab, $A)->insn_code = CODE_FOR_$(log$a2$)", 185 "optab_handler (log10_optab, $A)->insn_code = CODE_FOR_$(log10$a2$)", 186 "optab_handler (log2_optab, $A)->insn_code = CODE_FOR_$(log2$a2$)", 187 "optab_handler (log1p_optab, $A)->insn_code = CODE_FOR_$(log1p$a2$)", 188 "optab_handler (tan_optab, $A)->insn_code = CODE_FOR_$(tan$a2$)", 189 "optab_handler (atan_optab, $A)->insn_code = CODE_FOR_$(atan$a2$)", 190 "optab_handler (strlen_optab, $A)->insn_code = CODE_FOR_$(strlen$a$)", 191 "optab_handler (one_cmpl_optab, $A)->insn_code = CODE_FOR_$(one_cmpl$a2$)", 192 "optab_handler (bswap_optab, $A)->insn_code = CODE_FOR_$(bswap$a2$)", 193 "optab_handler (ffs_optab, $A)->insn_code = CODE_FOR_$(ffs$a2$)", 194 "optab_handler (clz_optab, $A)->insn_code = CODE_FOR_$(clz$a2$)", 195 "optab_handler (ctz_optab, $A)->insn_code = CODE_FOR_$(ctz$a2$)", 196 "optab_handler (popcount_optab, $A)->insn_code = CODE_FOR_$(popcount$a2$)", 197 "optab_handler (parity_optab, $A)->insn_code = CODE_FOR_$(parity$a2$)", 198 "optab_handler (mov_optab, $A)->insn_code = CODE_FOR_$(mov$a$)", 199 "optab_handler (movstrict_optab, $A)->insn_code = CODE_FOR_$(movstrict$a$)", 200 "optab_handler (movmisalign_optab, $A)->insn_code = CODE_FOR_$(movmisalign$a$)", 201 "optab_handler (storent_optab, $A)->insn_code = CODE_FOR_$(storent$a$)", 202 "optab_handler (addcc_optab, $A)->insn_code = CODE_FOR_$(add$acc$)", 203 "movcc_gen_code[$A] = CODE_FOR_$(mov$acc$)", 204 "optab_handler (cbranch_optab, $A)->insn_code = CODE_FOR_$(cbranch$a4$)", 205 "optab_handler (cmov_optab, $A)->insn_code = CODE_FOR_$(cmov$a6$)", 206 "optab_handler (cstore_optab, $A)->insn_code = CODE_FOR_$(cstore$a4$)", 207 "optab_handler (ctrap_optab, $A)->insn_code = CODE_FOR_$(ctrap$a4$)", 208 "optab_handler (push_optab, $A)->insn_code = CODE_FOR_$(push$a1$)", 209 "reload_in_optab[$A] = CODE_FOR_$(reload_in$a$)", 210 "reload_out_optab[$A] = CODE_FOR_$(reload_out$a$)", 211 "movmem_optab[$A] = CODE_FOR_$(movmem$a$)", 212 "cmpstr_optab[$A] = CODE_FOR_$(cmpstr$a$)", 213 "cmpstrn_optab[$A] = CODE_FOR_$(cmpstrn$a$)", 214 "cmpmem_optab[$A] = CODE_FOR_$(cmpmem$a$)", 215 "setmem_optab[$A] = CODE_FOR_$(setmem$a$)", 216 "sync_add_optab[$A] = CODE_FOR_$(sync_add$I$a$)", 217 "sync_sub_optab[$A] = CODE_FOR_$(sync_sub$I$a$)", 218 "sync_ior_optab[$A] = CODE_FOR_$(sync_ior$I$a$)", 219 "sync_and_optab[$A] = CODE_FOR_$(sync_and$I$a$)", 220 "sync_xor_optab[$A] = CODE_FOR_$(sync_xor$I$a$)", 221 "sync_nand_optab[$A] = CODE_FOR_$(sync_nand$I$a$)", 222 "sync_old_add_optab[$A] = CODE_FOR_$(sync_old_add$I$a$)", 223 "sync_old_sub_optab[$A] = CODE_FOR_$(sync_old_sub$I$a$)", 224 "sync_old_ior_optab[$A] = CODE_FOR_$(sync_old_ior$I$a$)", 225 "sync_old_and_optab[$A] = CODE_FOR_$(sync_old_and$I$a$)", 226 "sync_old_xor_optab[$A] = CODE_FOR_$(sync_old_xor$I$a$)", 227 "sync_old_nand_optab[$A] = CODE_FOR_$(sync_old_nand$I$a$)", 228 "sync_new_add_optab[$A] = CODE_FOR_$(sync_new_add$I$a$)", 229 "sync_new_sub_optab[$A] = CODE_FOR_$(sync_new_sub$I$a$)", 230 "sync_new_ior_optab[$A] = CODE_FOR_$(sync_new_ior$I$a$)", 231 "sync_new_and_optab[$A] = CODE_FOR_$(sync_new_and$I$a$)", 232 "sync_new_xor_optab[$A] = CODE_FOR_$(sync_new_xor$I$a$)", 233 "sync_new_nand_optab[$A] = CODE_FOR_$(sync_new_nand$I$a$)", 234 "sync_compare_and_swap[$A] = CODE_FOR_$(sync_compare_and_swap$I$a$)", 235 "sync_lock_test_and_set[$A] = CODE_FOR_$(sync_lock_test_and_set$I$a$)", 236 "sync_lock_release[$A] = CODE_FOR_$(sync_lock_release$I$a$)", 237 "optab_handler (vec_set_optab, $A)->insn_code = CODE_FOR_$(vec_set$a$)", 238 "optab_handler (vec_extract_optab, $A)->insn_code = CODE_FOR_$(vec_extract$a$)", 239 "optab_handler (vec_extract_even_optab, $A)->insn_code = CODE_FOR_$(vec_extract_even$a$)", 240 "optab_handler (vec_extract_odd_optab, $A)->insn_code = CODE_FOR_$(vec_extract_odd$a$)", 241 "optab_handler (vec_interleave_high_optab, $A)->insn_code = CODE_FOR_$(vec_interleave_high$a$)", 242 "optab_handler (vec_interleave_low_optab, $A)->insn_code = CODE_FOR_$(vec_interleave_low$a$)", 243 "optab_handler (vec_init_optab, $A)->insn_code = CODE_FOR_$(vec_init$a$)", 244 "optab_handler (vec_shl_optab, $A)->insn_code = CODE_FOR_$(vec_shl_$a$)", 245 "optab_handler (vec_shr_optab, $A)->insn_code = CODE_FOR_$(vec_shr_$a$)", 246 "optab_handler (vec_realign_load_optab, $A)->insn_code = CODE_FOR_$(vec_realign_load_$a$)", 247 "vcond_gen_code[$A] = CODE_FOR_$(vcond$a$)", 248 "vcondu_gen_code[$A] = CODE_FOR_$(vcondu$a$)", 249 "optab_handler (ssum_widen_optab, $A)->insn_code = CODE_FOR_$(widen_ssum$I$a3$)", 250 "optab_handler (usum_widen_optab, $A)->insn_code = CODE_FOR_$(widen_usum$I$a3$)", 251 "optab_handler (udot_prod_optab, $A)->insn_code = CODE_FOR_$(udot_prod$I$a$)", 252 "optab_handler (sdot_prod_optab, $A)->insn_code = CODE_FOR_$(sdot_prod$I$a$)", 253 "optab_handler (reduc_smax_optab, $A)->insn_code = CODE_FOR_$(reduc_smax_$a$)", 254 "optab_handler (reduc_umax_optab, $A)->insn_code = CODE_FOR_$(reduc_umax_$a$)", 255 "optab_handler (reduc_smin_optab, $A)->insn_code = CODE_FOR_$(reduc_smin_$a$)", 256 "optab_handler (reduc_umin_optab, $A)->insn_code = CODE_FOR_$(reduc_umin_$a$)", 257 "optab_handler (reduc_splus_optab, $A)->insn_code = CODE_FOR_$(reduc_splus_$a$)" , 258 "optab_handler (reduc_uplus_optab, $A)->insn_code = CODE_FOR_$(reduc_uplus_$a$)", 259 "optab_handler (vec_widen_umult_hi_optab, $A)->insn_code = CODE_FOR_$(vec_widen_umult_hi_$a$)", 260 "optab_handler (vec_widen_umult_lo_optab, $A)->insn_code = CODE_FOR_$(vec_widen_umult_lo_$a$)", 261 "optab_handler (vec_widen_smult_hi_optab, $A)->insn_code = CODE_FOR_$(vec_widen_smult_hi_$a$)", 262 "optab_handler (vec_widen_smult_lo_optab, $A)->insn_code = CODE_FOR_$(vec_widen_smult_lo_$a$)", 263 "optab_handler (vec_unpacks_hi_optab, $A)->insn_code = CODE_FOR_$(vec_unpacks_hi_$a$)", 264 "optab_handler (vec_unpacks_lo_optab, $A)->insn_code = CODE_FOR_$(vec_unpacks_lo_$a$)", 265 "optab_handler (vec_unpacku_hi_optab, $A)->insn_code = CODE_FOR_$(vec_unpacku_hi_$a$)", 266 "optab_handler (vec_unpacku_lo_optab, $A)->insn_code = CODE_FOR_$(vec_unpacku_lo_$a$)", 267 "optab_handler (vec_unpacks_float_hi_optab, $A)->insn_code = CODE_FOR_$(vec_unpacks_float_hi_$a$)", 268 "optab_handler (vec_unpacks_float_lo_optab, $A)->insn_code = CODE_FOR_$(vec_unpacks_float_lo_$a$)", 269 "optab_handler (vec_unpacku_float_hi_optab, $A)->insn_code = CODE_FOR_$(vec_unpacku_float_hi_$a$)", 270 "optab_handler (vec_unpacku_float_lo_optab, $A)->insn_code = CODE_FOR_$(vec_unpacku_float_lo_$a$)", 271 "optab_handler (vec_pack_trunc_optab, $A)->insn_code = CODE_FOR_$(vec_pack_trunc_$a$)", 272 "optab_handler (vec_pack_ssat_optab, $A)->insn_code = CODE_FOR_$(vec_pack_ssat_$a$)", 273 "optab_handler (vec_pack_usat_optab, $A)->insn_code = CODE_FOR_$(vec_pack_usat_$a$)", 274 "optab_handler (vec_pack_sfix_trunc_optab, $A)->insn_code = CODE_FOR_$(vec_pack_sfix_trunc_$a$)", 275 "optab_handler (vec_pack_ufix_trunc_optab, $A)->insn_code = CODE_FOR_$(vec_pack_ufix_trunc_$a$)" 276 }; 277 278 static void gen_insn (rtx); 279 280 static void 281 gen_insn (rtx insn) 282 { 283 const char *name = XSTR (insn, 0); 284 int m1 = 0, m2 = 0, op = 0; 285 size_t pindex; 286 int i; 287 const char *np, *pp, *p, *q; 288 289 /* Don't mention instructions whose names are the null string. 290 They are in the machine description just to be recognized. */ 291 if (*name == 0) 292 return; 293 294 /* See if NAME matches one of the patterns we have for the optabs we know 295 about. */ 296 297 for (pindex = 0; pindex < ARRAY_SIZE (optabs); pindex++) 298 { 299 int force_float = 0, force_int = 0, force_partial_int = 0; 300 int force_fixed = 0; 301 int force_consec = 0; 302 int matches = 1; 303 304 for (pp = optabs[pindex]; pp[0] != '$' || pp[1] != '('; pp++) 305 ; 306 307 for (pp += 2, np = name; matches && ! (pp[0] == '$' && pp[1] == ')'); 308 pp++) 309 { 310 if (*pp != '$') 311 { 312 if (*pp != *np++) 313 break; 314 } 315 else 316 switch (*++pp) 317 { 318 case 'N': 319 force_consec = 1; 320 break; 321 case 'I': 322 force_int = 1; 323 break; 324 case 'P': 325 force_partial_int = 1; 326 break; 327 case 'F': 328 force_float = 1; 329 break; 330 case 'Q': 331 force_fixed = 1; 332 break; 333 case 'V': 334 break; 335 case 'c': 336 for (op = 0; op < NUM_RTX_CODE; op++) 337 { 338 for (p = GET_RTX_NAME(op), q = np; *p; p++, q++) 339 if (*p != *q) 340 break; 341 342 /* We have to be concerned about matching "gt" and 343 missing "gtu", e.g., so verify we have reached the 344 end of thing we are to match. */ 345 if (*p == 0 && *q == 0 346 && (GET_RTX_CLASS (op) == RTX_COMPARE 347 || GET_RTX_CLASS (op) == RTX_COMM_COMPARE)) 348 break; 349 } 350 351 if (op == NUM_RTX_CODE) 352 matches = 0; 353 else 354 np += strlen (GET_RTX_NAME(op)); 355 break; 356 case 'a': 357 case 'b': 358 /* This loop will stop at the first prefix match, so 359 look through the modes in reverse order, in case 360 there are extra CC modes and CC is a prefix of the 361 CC modes (as it should be). */ 362 for (i = (MAX_MACHINE_MODE) - 1; i >= 0; i--) 363 { 364 for (p = GET_MODE_NAME(i), q = np; *p; p++, q++) 365 if (TOLOWER (*p) != *q) 366 break; 367 368 if (*p == 0 369 && (! force_int || mode_class[i] == MODE_INT 370 || mode_class[i] == MODE_VECTOR_INT) 371 && (! force_partial_int 372 || mode_class[i] == MODE_INT 373 || mode_class[i] == MODE_PARTIAL_INT 374 || mode_class[i] == MODE_VECTOR_INT) 375 && (! force_float 376 || mode_class[i] == MODE_FLOAT 377 || mode_class[i] == MODE_DECIMAL_FLOAT 378 || mode_class[i] == MODE_COMPLEX_FLOAT 379 || mode_class[i] == MODE_VECTOR_FLOAT) 380 && (! force_fixed 381 || mode_class[i] == MODE_FRACT 382 || mode_class[i] == MODE_UFRACT 383 || mode_class[i] == MODE_ACCUM 384 || mode_class[i] == MODE_UACCUM 385 || mode_class[i] == MODE_VECTOR_FRACT 386 || mode_class[i] == MODE_VECTOR_UFRACT 387 || mode_class[i] == MODE_VECTOR_ACCUM 388 || mode_class[i] == MODE_VECTOR_UACCUM)) 389 break; 390 } 391 392 if (i < 0) 393 matches = 0; 394 else if (*pp == 'a') 395 m1 = i, np += strlen (GET_MODE_NAME(i)); 396 else 397 m2 = i, np += strlen (GET_MODE_NAME(i)); 398 399 force_int = force_partial_int = force_float = force_fixed = 0; 400 break; 401 402 default: 403 gcc_unreachable (); 404 } 405 } 406 407 if (matches && pp[0] == '$' && pp[1] == ')' 408 && *np == 0 409 && (! force_consec || (int) GET_MODE_WIDER_MODE(m1) == m2)) 410 break; 411 } 412 413 if (pindex == ARRAY_SIZE (optabs)) 414 return; 415 416 /* We found a match. If this pattern is only conditionally present, 417 write out the "if" and two extra blanks. */ 418 419 if (*XSTR (insn, 2) != 0) 420 printf (" if (HAVE_%s)\n ", name); 421 422 printf (" "); 423 424 /* Now write out the initialization, making all required substitutions. */ 425 for (pp = optabs[pindex]; *pp; pp++) 426 { 427 if (*pp != '$') 428 putchar (*pp); 429 else 430 switch (*++pp) 431 { 432 case '(': case ')': 433 case 'I': case 'F': case 'N': 434 break; 435 case 'V': 436 if (SCALAR_FLOAT_MODE_P (m1)) 437 printf ("v"); 438 break; 439 case 'a': 440 for (np = GET_MODE_NAME(m1); *np; np++) 441 putchar (TOLOWER (*np)); 442 break; 443 case 'b': 444 for (np = GET_MODE_NAME(m2); *np; np++) 445 putchar (TOLOWER (*np)); 446 break; 447 case 'A': 448 printf ("%smode", GET_MODE_NAME(m1)); 449 break; 450 case 'B': 451 printf ("%smode", GET_MODE_NAME(m2)); 452 break; 453 case 'c': 454 printf ("%s", GET_RTX_NAME(op)); 455 break; 456 case 'C': 457 for (np = GET_RTX_NAME(op); *np; np++) 458 putchar (TOUPPER (*np)); 459 break; 460 } 461 } 462 463 printf (";\n"); 464 } 465 466 extern int main (int, char **); 467 468 int 469 main (int argc, char **argv) 470 { 471 rtx desc; 472 473 progname = "genopinit"; 474 475 if (init_md_reader_args (argc, argv) != SUCCESS_EXIT_CODE) 476 return (FATAL_EXIT_CODE); 477 478 printf ("/* Generated automatically by the program `genopinit'\n\ 479 from the machine description file `md'. */\n\n"); 480 481 printf ("#include \"config.h\"\n"); 482 printf ("#include \"system.h\"\n"); 483 printf ("#include \"coretypes.h\"\n"); 484 printf ("#include \"tm.h\"\n"); 485 printf ("#include \"rtl.h\"\n"); 486 printf ("#include \"tm_p.h\"\n"); 487 printf ("#include \"flags.h\"\n"); 488 printf ("#include \"insn-config.h\"\n"); 489 printf ("#include \"recog.h\"\n"); 490 printf ("#include \"expr.h\"\n"); 491 printf ("#include \"optabs.h\"\n"); 492 printf ("#include \"reload.h\"\n\n"); 493 494 printf ("void\ninit_all_optabs (void)\n{\n"); 495 496 puts ("\ 497 #ifdef FIXUNS_TRUNC_LIKE_FIX_TRUNC\n\ 498 int i, j;\n\ 499 #endif\n"); 500 501 /* Read the machine description. */ 502 503 while (1) 504 { 505 int line_no, insn_code_number = 0; 506 507 desc = read_md_rtx (&line_no, &insn_code_number); 508 if (desc == NULL) 509 break; 510 511 if (GET_CODE (desc) == DEFINE_INSN || GET_CODE (desc) == DEFINE_EXPAND) 512 gen_insn (desc); 513 } 514 515 puts ("\ 516 \n\ 517 #ifdef FIXUNS_TRUNC_LIKE_FIX_TRUNC\n\ 518 /* This flag says the same insns that convert to a signed fixnum\n\ 519 also convert validly to an unsigned one. */\n\ 520 for (i = 0; i < NUM_MACHINE_MODES; i++)\n\ 521 for (j = 0; j < NUM_MACHINE_MODES; j++)\n\ 522 convert_optab_handler (ufixtrunc_optab, i, j)->insn_code\n\ 523 = convert_optab_handler (sfixtrunc_optab, i, j)->insn_code;\n\ 524 #endif\n\ 525 }"); 526 527 fflush (stdout); 528 return (ferror (stdout) != 0 ? FATAL_EXIT_CODE : SUCCESS_EXIT_CODE); 529 } 530