OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gcc-4.5.1/] [gcc/] [genopinit.c] - Blame information for rev 304

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 280 jeremybenn
/* 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
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.