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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gcc-4.2.2/] [gcc/] [genopinit.c] - Blame information for rev 816

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 38 julius
/* 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 Free Software Foundation, Inc.
4
 
5
This file is part of GCC.
6
 
7
GCC is free software; you can redistribute it and/or modify it under
8
the terms of the GNU General Public License as published by the Free
9
Software Foundation; either version 3, or (at your option) any later
10
version.
11
 
12
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13
WARRANTY; without even the implied warranty of MERCHANTABILITY or
14
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
15
for more details.
16
 
17
You should have received a copy of the GNU General Public License
18
along with GCC; see the file COPYING3.  If not see
19
<http://www.gnu.org/licenses/>.  */
20
 
21
 
22
#include "bconfig.h"
23
#include "system.h"
24
#include "coretypes.h"
25
#include "tm.h"
26
#include "rtl.h"
27
#include "errors.h"
28
#include "gensupport.h"
29
 
30
 
31
/* Many parts of GCC use arrays that are indexed by machine mode and
32
   contain the insn codes for pattern in the MD file that perform a given
33
   operation on operands of that mode.
34
 
35
   These patterns are present in the MD file with names that contain
36
   the mode(s) used and the name of the operation.  This program
37
   writes a function `init_all_optabs' that initializes the optabs with
38
   all the insn codes of the relevant patterns present in the MD file.
39
 
40
   This array contains a list of optabs that need to be initialized.  Within
41
   each string, the name of the pattern to be matched against is delimited
42
   with $( and $).  In the string, $a and $b are used to match a short mode
43
   name (the part of the mode name not including `mode' and converted to
44
   lower-case).  When writing out the initializer, the entire string is
45
   used.  $A and $B are replaced with the full name of the mode; $a and $b
46
   are replaced with the short form of the name, as above.
47
 
48
   If $N is present in the pattern, it means the two modes must be consecutive
49
   widths in the same mode class (e.g, QImode and HImode).  $I means that
50
   only full integer modes should be considered for the next mode, and $F
51
   means that only float modes should be considered.
52
   $P means that both full and partial integer modes should be considered.
53
 
54
   $V means to emit 'v' if the first mode is a MODE_FLOAT mode.
55
 
56
   For some optabs, we store the operation by RTL codes.  These are only
57
   used for comparisons.  In that case, $c and $C are the lower-case and
58
   upper-case forms of the comparison, respectively.  */
59
 
60
static const char * const optabs[] =
61
{ "sext_optab->handlers[$B][$A].insn_code = CODE_FOR_$(extend$a$b2$)",
62
  "zext_optab->handlers[$B][$A].insn_code = CODE_FOR_$(zero_extend$a$b2$)",
63
  "sfix_optab->handlers[$B][$A].insn_code = CODE_FOR_$(fix$F$a$I$b2$)",
64
  "ufix_optab->handlers[$B][$A].insn_code = CODE_FOR_$(fixuns$F$a$b2$)",
65
  "sfixtrunc_optab->handlers[$B][$A].insn_code = CODE_FOR_$(fix_trunc$F$a$I$b2$)",
66
  "ufixtrunc_optab->handlers[$B][$A].insn_code = CODE_FOR_$(fixuns_trunc$F$a$I$b2$)",
67
  "sfloat_optab->handlers[$B][$A].insn_code = CODE_FOR_$(float$I$a$F$b2$)",
68
  "ufloat_optab->handlers[$B][$A].insn_code = CODE_FOR_$(floatuns$I$a$F$b2$)",
69
  "trunc_optab->handlers[$B][$A].insn_code = CODE_FOR_$(trunc$a$b2$)",
70
  "add_optab->handlers[$A].insn_code = CODE_FOR_$(add$P$a3$)",
71
  "addv_optab->handlers[$A].insn_code =\n\
72
    add_optab->handlers[$A].insn_code = CODE_FOR_$(add$F$a3$)",
73
  "addv_optab->handlers[$A].insn_code = CODE_FOR_$(addv$I$a3$)",
74
  "sub_optab->handlers[$A].insn_code = CODE_FOR_$(sub$P$a3$)",
75
  "subv_optab->handlers[$A].insn_code =\n\
76
    sub_optab->handlers[$A].insn_code = CODE_FOR_$(sub$F$a3$)",
77
  "subv_optab->handlers[$A].insn_code = CODE_FOR_$(subv$I$a3$)",
78
  "smul_optab->handlers[$A].insn_code = CODE_FOR_$(mul$P$a3$)",
79
  "smulv_optab->handlers[$A].insn_code =\n\
80
    smul_optab->handlers[$A].insn_code = CODE_FOR_$(mul$F$a3$)",
81
  "smulv_optab->handlers[$A].insn_code = CODE_FOR_$(mulv$I$a3$)",
82
  "umul_highpart_optab->handlers[$A].insn_code = CODE_FOR_$(umul$a3_highpart$)",
83
  "smul_highpart_optab->handlers[$A].insn_code = CODE_FOR_$(smul$a3_highpart$)",
84
  "smul_widen_optab->handlers[$B].insn_code = CODE_FOR_$(mul$a$b3$)$N",
85
  "umul_widen_optab->handlers[$B].insn_code = CODE_FOR_$(umul$a$b3$)$N",
86
  "usmul_widen_optab->handlers[$B].insn_code = CODE_FOR_$(usmul$a$b3$)$N",
87
  "sdiv_optab->handlers[$A].insn_code = CODE_FOR_$(div$a3$)",
88
  "sdivv_optab->handlers[$A].insn_code = CODE_FOR_$(div$V$I$a3$)",
89
  "udiv_optab->handlers[$A].insn_code = CODE_FOR_$(udiv$I$a3$)",
90
  "sdivmod_optab->handlers[$A].insn_code = CODE_FOR_$(divmod$a4$)",
91
  "udivmod_optab->handlers[$A].insn_code = CODE_FOR_$(udivmod$a4$)",
92
  "smod_optab->handlers[$A].insn_code = CODE_FOR_$(mod$a3$)",
93
  "umod_optab->handlers[$A].insn_code = CODE_FOR_$(umod$a3$)",
94
  "fmod_optab->handlers[$A].insn_code = CODE_FOR_$(fmod$a3$)",
95
  "drem_optab->handlers[$A].insn_code = CODE_FOR_$(drem$a3$)",
96
  "ftrunc_optab->handlers[$A].insn_code = CODE_FOR_$(ftrunc$F$a2$)",
97
  "and_optab->handlers[$A].insn_code = CODE_FOR_$(and$a3$)",
98
  "ior_optab->handlers[$A].insn_code = CODE_FOR_$(ior$a3$)",
99
  "xor_optab->handlers[$A].insn_code = CODE_FOR_$(xor$a3$)",
100
  "ashl_optab->handlers[$A].insn_code = CODE_FOR_$(ashl$a3$)",
101
  "ashr_optab->handlers[$A].insn_code = CODE_FOR_$(ashr$a3$)",
102
  "lshr_optab->handlers[$A].insn_code = CODE_FOR_$(lshr$a3$)",
103
  "rotl_optab->handlers[$A].insn_code = CODE_FOR_$(rotl$a3$)",
104
  "rotr_optab->handlers[$A].insn_code = CODE_FOR_$(rotr$a3$)",
105
  "smin_optab->handlers[$A].insn_code = CODE_FOR_$(smin$a3$)",
106
  "smax_optab->handlers[$A].insn_code = CODE_FOR_$(smax$a3$)",
107
  "umin_optab->handlers[$A].insn_code = CODE_FOR_$(umin$I$a3$)",
108
  "umax_optab->handlers[$A].insn_code = CODE_FOR_$(umax$I$a3$)",
109
  "pow_optab->handlers[$A].insn_code = CODE_FOR_$(pow$a3$)",
110
  "atan2_optab->handlers[$A].insn_code = CODE_FOR_$(atan2$a3$)",
111
  "neg_optab->handlers[$A].insn_code = CODE_FOR_$(neg$P$a2$)",
112
  "negv_optab->handlers[$A].insn_code =\n\
113
    neg_optab->handlers[$A].insn_code = CODE_FOR_$(neg$F$a2$)",
114
  "negv_optab->handlers[$A].insn_code = CODE_FOR_$(negv$I$a2$)",
115
  "abs_optab->handlers[$A].insn_code = CODE_FOR_$(abs$P$a2$)",
116
  "absv_optab->handlers[$A].insn_code =\n\
117
    abs_optab->handlers[$A].insn_code = CODE_FOR_$(abs$F$a2$)",
118
  "absv_optab->handlers[$A].insn_code = CODE_FOR_$(absv$I$a2$)",
119
  "copysign_optab->handlers[$A].insn_code = CODE_FOR_$(copysign$F$a3$)",
120
  "sqrt_optab->handlers[$A].insn_code = CODE_FOR_$(sqrt$a2$)",
121
  "floor_optab->handlers[$A].insn_code = CODE_FOR_$(floor$a2$)",
122
  "lfloor_optab->handlers[$A].insn_code = CODE_FOR_$(lfloor$a2$)",
123
  "ceil_optab->handlers[$A].insn_code = CODE_FOR_$(ceil$a2$)",
124
  "lceil_optab->handlers[$A].insn_code = CODE_FOR_$(lceil$a2$)",
125
  "round_optab->handlers[$A].insn_code = CODE_FOR_$(round$a2$)",
126
  "btrunc_optab->handlers[$A].insn_code = CODE_FOR_$(btrunc$a2$)",
127
  "nearbyint_optab->handlers[$A].insn_code = CODE_FOR_$(nearbyint$a2$)",
128
  "rint_optab->handlers[$A].insn_code = CODE_FOR_$(rint$a2$)",
129
  "lrint_optab->handlers[$A].insn_code = CODE_FOR_$(lrint$a2$)",
130
  "sincos_optab->handlers[$A].insn_code = CODE_FOR_$(sincos$a3$)",
131
  "sin_optab->handlers[$A].insn_code = CODE_FOR_$(sin$a2$)",
132
  "asin_optab->handlers[$A].insn_code = CODE_FOR_$(asin$a2$)",
133
  "cos_optab->handlers[$A].insn_code = CODE_FOR_$(cos$a2$)",
134
  "acos_optab->handlers[$A].insn_code = CODE_FOR_$(acos$a2$)",
135
  "exp_optab->handlers[$A].insn_code = CODE_FOR_$(exp$a2$)",
136
  "exp10_optab->handlers[$A].insn_code = CODE_FOR_$(exp10$a2$)",
137
  "exp2_optab->handlers[$A].insn_code = CODE_FOR_$(exp2$a2$)",
138
  "expm1_optab->handlers[$A].insn_code = CODE_FOR_$(expm1$a2$)",
139
  "ldexp_optab->handlers[$A].insn_code = CODE_FOR_$(ldexp$a3$)",
140
  "logb_optab->handlers[$A].insn_code = CODE_FOR_$(logb$a2$)",
141
  "ilogb_optab->handlers[$A].insn_code = CODE_FOR_$(ilogb$a2$)",
142
  "log_optab->handlers[$A].insn_code = CODE_FOR_$(log$a2$)",
143
  "log10_optab->handlers[$A].insn_code = CODE_FOR_$(log10$a2$)",
144
  "log2_optab->handlers[$A].insn_code = CODE_FOR_$(log2$a2$)",
145
  "log1p_optab->handlers[$A].insn_code = CODE_FOR_$(log1p$a2$)",
146
  "tan_optab->handlers[$A].insn_code = CODE_FOR_$(tan$a2$)",
147
  "atan_optab->handlers[$A].insn_code = CODE_FOR_$(atan$a2$)",
148
  "strlen_optab->handlers[$A].insn_code = CODE_FOR_$(strlen$a$)",
149
  "one_cmpl_optab->handlers[$A].insn_code = CODE_FOR_$(one_cmpl$a2$)",
150
  "ffs_optab->handlers[$A].insn_code = CODE_FOR_$(ffs$a2$)",
151
  "clz_optab->handlers[$A].insn_code = CODE_FOR_$(clz$a2$)",
152
  "ctz_optab->handlers[$A].insn_code = CODE_FOR_$(ctz$a2$)",
153
  "popcount_optab->handlers[$A].insn_code = CODE_FOR_$(popcount$a2$)",
154
  "parity_optab->handlers[$A].insn_code = CODE_FOR_$(parity$a2$)",
155
  "mov_optab->handlers[$A].insn_code = CODE_FOR_$(mov$a$)",
156
  "movstrict_optab->handlers[$A].insn_code = CODE_FOR_$(movstrict$a$)",
157
  "movmisalign_optab->handlers[$A].insn_code = CODE_FOR_$(movmisalign$a$)",
158
  "cmp_optab->handlers[$A].insn_code = CODE_FOR_$(cmp$a$)",
159
  "tst_optab->handlers[$A].insn_code = CODE_FOR_$(tst$a$)",
160
  "addcc_optab->handlers[$A].insn_code = CODE_FOR_$(add$acc$)",
161
  "bcc_gen_fctn[$C] = gen_$(b$c$)",
162
  "setcc_gen_code[$C] = CODE_FOR_$(s$c$)",
163
  "movcc_gen_code[$A] = CODE_FOR_$(mov$acc$)",
164
  "cbranch_optab->handlers[$A].insn_code = CODE_FOR_$(cbranch$a4$)",
165
  "cmov_optab->handlers[$A].insn_code = CODE_FOR_$(cmov$a6$)",
166
  "cstore_optab->handlers[$A].insn_code = CODE_FOR_$(cstore$a4$)",
167
  "push_optab->handlers[$A].insn_code = CODE_FOR_$(push$a1$)",
168
  "reload_in_optab[$A] = CODE_FOR_$(reload_in$a$)",
169
  "reload_out_optab[$A] = CODE_FOR_$(reload_out$a$)",
170
  "movmem_optab[$A] = CODE_FOR_$(movmem$a$)",
171
  "cmpstr_optab[$A] = CODE_FOR_$(cmpstr$a$)",
172
  "cmpstrn_optab[$A] = CODE_FOR_$(cmpstrn$a$)",
173
  "cmpmem_optab[$A] = CODE_FOR_$(cmpmem$a$)",
174
  "setmem_optab[$A] = CODE_FOR_$(setmem$a$)",
175
  "sync_add_optab[$A] = CODE_FOR_$(sync_add$I$a$)",
176
  "sync_sub_optab[$A] = CODE_FOR_$(sync_sub$I$a$)",
177
  "sync_ior_optab[$A] = CODE_FOR_$(sync_ior$I$a$)",
178
  "sync_and_optab[$A] = CODE_FOR_$(sync_and$I$a$)",
179
  "sync_xor_optab[$A] = CODE_FOR_$(sync_xor$I$a$)",
180
  "sync_nand_optab[$A] = CODE_FOR_$(sync_nand$I$a$)",
181
  "sync_old_add_optab[$A] = CODE_FOR_$(sync_old_add$I$a$)",
182
  "sync_old_sub_optab[$A] = CODE_FOR_$(sync_old_sub$I$a$)",
183
  "sync_old_ior_optab[$A] = CODE_FOR_$(sync_old_ior$I$a$)",
184
  "sync_old_and_optab[$A] = CODE_FOR_$(sync_old_and$I$a$)",
185
  "sync_old_xor_optab[$A] = CODE_FOR_$(sync_old_xor$I$a$)",
186
  "sync_old_nand_optab[$A] = CODE_FOR_$(sync_old_nand$I$a$)",
187
  "sync_new_add_optab[$A] = CODE_FOR_$(sync_new_add$I$a$)",
188
  "sync_new_sub_optab[$A] = CODE_FOR_$(sync_new_sub$I$a$)",
189
  "sync_new_ior_optab[$A] = CODE_FOR_$(sync_new_ior$I$a$)",
190
  "sync_new_and_optab[$A] = CODE_FOR_$(sync_new_and$I$a$)",
191
  "sync_new_xor_optab[$A] = CODE_FOR_$(sync_new_xor$I$a$)",
192
  "sync_new_nand_optab[$A] = CODE_FOR_$(sync_new_nand$I$a$)",
193
  "sync_compare_and_swap[$A] = CODE_FOR_$(sync_compare_and_swap$I$a$)",
194
  "sync_compare_and_swap_cc[$A] = CODE_FOR_$(sync_compare_and_swap_cc$I$a$)",
195
  "sync_lock_test_and_set[$A] = CODE_FOR_$(sync_lock_test_and_set$I$a$)",
196
  "sync_lock_release[$A] = CODE_FOR_$(sync_lock_release$I$a$)",
197
  "vec_set_optab->handlers[$A].insn_code = CODE_FOR_$(vec_set$a$)",
198
  "vec_extract_optab->handlers[$A].insn_code = CODE_FOR_$(vec_extract$a$)",
199
  "vec_init_optab->handlers[$A].insn_code = CODE_FOR_$(vec_init$a$)",
200
  "vec_shl_optab->handlers[$A].insn_code = CODE_FOR_$(vec_shl_$a$)",
201
  "vec_shr_optab->handlers[$A].insn_code = CODE_FOR_$(vec_shr_$a$)",
202
  "vec_realign_load_optab->handlers[$A].insn_code = CODE_FOR_$(vec_realign_load_$a$)",
203
  "vcond_gen_code[$A] = CODE_FOR_$(vcond$a$)",
204
  "vcondu_gen_code[$A] = CODE_FOR_$(vcondu$a$)",
205
  "ssum_widen_optab->handlers[$A].insn_code = CODE_FOR_$(widen_ssum$I$a3$)",
206
  "usum_widen_optab->handlers[$A].insn_code = CODE_FOR_$(widen_usum$I$a3$)",
207
  "udot_prod_optab->handlers[$A].insn_code = CODE_FOR_$(udot_prod$I$a$)",
208
  "sdot_prod_optab->handlers[$A].insn_code = CODE_FOR_$(sdot_prod$I$a$)",
209
  "reduc_smax_optab->handlers[$A].insn_code = CODE_FOR_$(reduc_smax_$a$)",
210
  "reduc_umax_optab->handlers[$A].insn_code = CODE_FOR_$(reduc_umax_$a$)",
211
  "reduc_smin_optab->handlers[$A].insn_code = CODE_FOR_$(reduc_smin_$a$)",
212
  "reduc_umin_optab->handlers[$A].insn_code = CODE_FOR_$(reduc_umin_$a$)",
213
  "reduc_splus_optab->handlers[$A].insn_code = CODE_FOR_$(reduc_splus_$a$)" ,
214
  "reduc_uplus_optab->handlers[$A].insn_code = CODE_FOR_$(reduc_uplus_$a$)"
215
};
216
 
217
static void gen_insn (rtx);
218
 
219
static void
220
gen_insn (rtx insn)
221
{
222
  const char *name = XSTR (insn, 0);
223
  int m1 = 0, m2 = 0, op = 0;
224
  size_t pindex;
225
  int i;
226
  const char *np, *pp, *p, *q;
227
 
228
  /* Don't mention instructions whose names are the null string.
229
     They are in the machine description just to be recognized.  */
230
  if (*name == 0)
231
    return;
232
 
233
  /* See if NAME matches one of the patterns we have for the optabs we know
234
     about.  */
235
 
236
  for (pindex = 0; pindex < ARRAY_SIZE (optabs); pindex++)
237
    {
238
      int force_float = 0, force_int = 0, force_partial_int = 0;
239
      int force_consec = 0;
240
      int matches = 1;
241
 
242
      for (pp = optabs[pindex]; pp[0] != '$' || pp[1] != '('; pp++)
243
        ;
244
 
245
      for (pp += 2, np = name; matches && ! (pp[0] == '$' && pp[1] == ')');
246
           pp++)
247
        {
248
          if (*pp != '$')
249
            {
250
              if (*pp != *np++)
251
                break;
252
            }
253
          else
254
            switch (*++pp)
255
              {
256
              case 'N':
257
                force_consec = 1;
258
                break;
259
              case 'I':
260
                force_int = 1;
261
                break;
262
              case 'P':
263
                force_partial_int = 1;
264
                break;
265
              case 'F':
266
                force_float = 1;
267
                break;
268
              case 'V':
269
                break;
270
              case 'c':
271
                for (op = 0; op < NUM_RTX_CODE; op++)
272
                  {
273
                    for (p = GET_RTX_NAME(op), q = np; *p; p++, q++)
274
                      if (*p != *q)
275
                        break;
276
 
277
                    /* We have to be concerned about matching "gt" and
278
                       missing "gtu", e.g., so verify we have reached the
279
                       end of thing we are to match.  */
280
                    if (*p == 0 && *q == 0
281
                        && (GET_RTX_CLASS (op) == RTX_COMPARE
282
                            || GET_RTX_CLASS (op) == RTX_COMM_COMPARE))
283
                      break;
284
                  }
285
 
286
                if (op == NUM_RTX_CODE)
287
                  matches = 0;
288
                else
289
                  np += strlen (GET_RTX_NAME(op));
290
                break;
291
              case 'a':
292
              case 'b':
293
                /* This loop will stop at the first prefix match, so
294
                   look through the modes in reverse order, in case
295
                   there are extra CC modes and CC is a prefix of the
296
                   CC modes (as it should be).  */
297
                for (i = (MAX_MACHINE_MODE) - 1; i >= 0; i--)
298
                  {
299
                    for (p = GET_MODE_NAME(i), q = np; *p; p++, q++)
300
                      if (TOLOWER (*p) != *q)
301
                        break;
302
 
303
                    if (*p == 0
304
                        && (! force_int || mode_class[i] == MODE_INT
305
                            || mode_class[i] == MODE_VECTOR_INT)
306
                        && (! force_partial_int
307
                            || mode_class[i] == MODE_INT
308
                            || mode_class[i] == MODE_PARTIAL_INT
309
                            || mode_class[i] == MODE_VECTOR_INT)
310
                        && (! force_float
311
                            || mode_class[i] == MODE_FLOAT
312
                            || mode_class[i] == MODE_DECIMAL_FLOAT
313
                            || mode_class[i] == MODE_COMPLEX_FLOAT
314
                            || mode_class[i] == MODE_VECTOR_FLOAT))
315
                      break;
316
                  }
317
 
318
                if (i < 0)
319
                  matches = 0;
320
                else if (*pp == 'a')
321
                  m1 = i, np += strlen (GET_MODE_NAME(i));
322
                else
323
                  m2 = i, np += strlen (GET_MODE_NAME(i));
324
 
325
                force_int = force_partial_int = force_float = 0;
326
                break;
327
 
328
              default:
329
                gcc_unreachable ();
330
              }
331
        }
332
 
333
      if (matches && pp[0] == '$' && pp[1] == ')'
334
          && *np == 0
335
          && (! force_consec || (int) GET_MODE_WIDER_MODE(m1) == m2))
336
        break;
337
    }
338
 
339
  if (pindex == ARRAY_SIZE (optabs))
340
    return;
341
 
342
  /* We found a match.  If this pattern is only conditionally present,
343
     write out the "if" and two extra blanks.  */
344
 
345
  if (*XSTR (insn, 2) != 0)
346
    printf ("  if (HAVE_%s)\n  ", name);
347
 
348
  printf ("  ");
349
 
350
  /* Now write out the initialization, making all required substitutions.  */
351
  for (pp = optabs[pindex]; *pp; pp++)
352
    {
353
      if (*pp != '$')
354
        putchar (*pp);
355
      else
356
        switch (*++pp)
357
          {
358
          case '(':  case ')':
359
          case 'I':  case 'F':  case 'N':
360
            break;
361
          case 'V':
362
            if (SCALAR_FLOAT_MODE_P (m1))
363
              printf ("v");
364
            break;
365
          case 'a':
366
            for (np = GET_MODE_NAME(m1); *np; np++)
367
              putchar (TOLOWER (*np));
368
            break;
369
          case 'b':
370
            for (np = GET_MODE_NAME(m2); *np; np++)
371
              putchar (TOLOWER (*np));
372
            break;
373
          case 'A':
374
            printf ("%smode", GET_MODE_NAME(m1));
375
            break;
376
          case 'B':
377
            printf ("%smode", GET_MODE_NAME(m2));
378
            break;
379
          case 'c':
380
            printf ("%s", GET_RTX_NAME(op));
381
            break;
382
          case 'C':
383
            for (np = GET_RTX_NAME(op); *np; np++)
384
              putchar (TOUPPER (*np));
385
            break;
386
          }
387
    }
388
 
389
  printf (";\n");
390
}
391
 
392
extern int main (int, char **);
393
 
394
int
395
main (int argc, char **argv)
396
{
397
  rtx desc;
398
 
399
  progname = "genopinit";
400
 
401
  if (init_md_reader_args (argc, argv) != SUCCESS_EXIT_CODE)
402
    return (FATAL_EXIT_CODE);
403
 
404
  printf ("/* Generated automatically by the program `genopinit'\n\
405
from the machine description file `md'.  */\n\n");
406
 
407
  printf ("#include \"config.h\"\n");
408
  printf ("#include \"system.h\"\n");
409
  printf ("#include \"coretypes.h\"\n");
410
  printf ("#include \"tm.h\"\n");
411
  printf ("#include \"rtl.h\"\n");
412
  printf ("#include \"flags.h\"\n");
413
  printf ("#include \"insn-config.h\"\n");
414
  printf ("#include \"recog.h\"\n");
415
  printf ("#include \"expr.h\"\n");
416
  printf ("#include \"optabs.h\"\n");
417
  printf ("#include \"reload.h\"\n\n");
418
 
419
  printf ("void\ninit_all_optabs (void)\n{\n");
420
 
421
  puts ("\
422
#ifdef FIXUNS_TRUNC_LIKE_FIX_TRUNC\n\
423
  int i, j;\n\
424
#endif\n");
425
 
426
  /* Read the machine description.  */
427
 
428
  while (1)
429
    {
430
      int line_no, insn_code_number = 0;
431
 
432
      desc = read_md_rtx (&line_no, &insn_code_number);
433
      if (desc == NULL)
434
        break;
435
 
436
      if (GET_CODE (desc) == DEFINE_INSN || GET_CODE (desc) == DEFINE_EXPAND)
437
        gen_insn (desc);
438
    }
439
 
440
  puts ("\
441
\n\
442
#ifdef FIXUNS_TRUNC_LIKE_FIX_TRUNC\n\
443
  /* This flag says the same insns that convert to a signed fixnum\n\
444
     also convert validly to an unsigned one.  */\n\
445
  for (i = 0; i < NUM_MACHINE_MODES; i++)\n\
446
    for (j = 0; j < NUM_MACHINE_MODES; j++)\n\
447
      ufixtrunc_optab->handlers[i][j].insn_code\n\
448
      = sfixtrunc_optab->handlers[i][j].insn_code;\n\
449
#endif\n\
450
}");
451
 
452
  fflush (stdout);
453
  return (ferror (stdout) != 0 ? FATAL_EXIT_CODE : SUCCESS_EXIT_CODE);
454
}

powered by: WebSVN 2.1.0

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