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

Subversion Repositories openrisc_me

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

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 280 jeremybenn
/* Generate code to allocate RTL structures.
2
   Copyright (C) 1997, 1998, 1999, 2000, 2002, 2003, 2004, 2007
3
   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
 
25
struct rtx_definition
26
{
27
  const char *const enumname, *const name, *const format;
28
};
29
 
30
/* rtl.def needs CONST_DOUBLE_FORMAT, but we don't care what
31
   CONST_DOUBLE_FORMAT is because we're not going to be generating
32
   anything for CONST_DOUBLE anyway.  */
33
#define CONST_DOUBLE_FORMAT ""
34
 
35
#define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) { #ENUM, NAME, FORMAT },
36
 
37
static const struct rtx_definition defs[] =
38
{
39
#include "rtl.def"              /* rtl expressions are documented here */
40
};
41
#define NUM_RTX_CODE ARRAY_SIZE(defs)
42
 
43
static const char *formats[NUM_RTX_CODE];
44
 
45
static const char *type_from_format     (int);
46
static const char *accessor_from_format (int);
47
static int special_format               (const char *);
48
static int special_rtx                  (int);
49
static int excluded_rtx                 (int);
50
static void find_formats                (void);
51
static void gendecl                     (const char *);
52
static void genmacro                    (int);
53
static void gendef                      (const char *);
54
static void genlegend                   (void);
55
static void genheader                   (void);
56
static void gencode                     (void);
57
 
58
/* Decode a format letter into a C type string.  */
59
 
60
static const char *
61
type_from_format (int c)
62
{
63
  switch (c)
64
    {
65
    case 'i':
66
      return "int ";
67
 
68
    case 'w':
69
      return "HOST_WIDE_INT ";
70
 
71
    case 's':
72
      return "const char *";
73
 
74
    case 'e':  case 'u':
75
      return "rtx ";
76
 
77
    case 'E':
78
      return "rtvec ";
79
    case 'b':
80
      return "struct bitmap_head_def *";  /* bitmap - typedef not available */
81
    case 't':
82
      return "union tree_node *";  /* tree - typedef not available */
83
    case 'B':
84
      return "struct basic_block_def *";  /* basic block - typedef not available */
85
    default:
86
      gcc_unreachable ();
87
    }
88
}
89
 
90
/* Decode a format letter into the proper accessor function.  */
91
 
92
static const char *
93
accessor_from_format (int c)
94
{
95
  switch (c)
96
    {
97
    case 'i':
98
      return "XINT";
99
 
100
    case 'w':
101
      return "XWINT";
102
 
103
    case 's':
104
      return "XSTR";
105
 
106
    case 'e':  case 'u':
107
      return "XEXP";
108
 
109
    case 'E':
110
      return "XVEC";
111
 
112
    case 'b':
113
      return "XBITMAP";
114
 
115
    case 't':
116
      return "XTREE";
117
 
118
    case 'B':
119
      return "XBBDEF";
120
 
121
    default:
122
      gcc_unreachable ();
123
    }
124
}
125
 
126
/* Return nonzero if we should ignore FMT, an RTL format, when making
127
   the list of formats we write routines to create.  */
128
 
129
static int
130
special_format (const char *fmt)
131
{
132
  return (strchr (fmt, '*') != 0
133
          || strchr (fmt, 'V') != 0
134
          || strchr (fmt, 'S') != 0
135
          || strchr (fmt, 'n') != 0);
136
}
137
 
138
/* Return nonzero if the RTL code given by index IDX is one that we should
139
   generate a gen_rtx_raw_FOO macro for, not gen_rtx_FOO (because gen_rtx_FOO
140
   is a wrapper in emit-rtl.c).  */
141
 
142
static int
143
special_rtx (int idx)
144
{
145
  return (strcmp (defs[idx].enumname, "CONST_INT") == 0
146
          || strcmp (defs[idx].enumname, "REG") == 0
147
          || strcmp (defs[idx].enumname, "SUBREG") == 0
148
          || strcmp (defs[idx].enumname, "MEM") == 0
149
          || strcmp (defs[idx].enumname, "CONST_VECTOR") == 0);
150
}
151
 
152
/* Return nonzero if the RTL code given by index IDX is one that we should
153
   generate no macro for at all (because gen_rtx_FOO is never used or
154
   cannot have the obvious interface).  */
155
 
156
static int
157
excluded_rtx (int idx)
158
{
159
  return ((strcmp (defs[idx].enumname, "CONST_DOUBLE") == 0)
160
          || (strcmp (defs[idx].enumname, "CONST_FIXED") == 0));
161
}
162
 
163
/* Place a list of all format specifiers we use into the array FORMAT.  */
164
 
165
static void
166
find_formats (void)
167
{
168
  unsigned int i;
169
 
170
  for (i = 0; i < NUM_RTX_CODE; i++)
171
    {
172
      const char **f;
173
 
174
      if (special_format (defs[i].format))
175
        continue;
176
 
177
      for (f = formats; *f; f++)
178
        if (! strcmp (*f, defs[i].format))
179
          break;
180
 
181
      if (*f == 0)
182
        *f = defs[i].format;
183
    }
184
}
185
 
186
/* Write the declarations for the routine to allocate RTL with FORMAT.  */
187
 
188
static void
189
gendecl (const char *format)
190
{
191
  const char *p;
192
  int i, pos;
193
 
194
  printf ("extern rtx gen_rtx_fmt_%s_stat\t (RTX_CODE, ", format);
195
  printf ("enum machine_mode mode");
196
 
197
  /* Write each parameter that is needed and start a new line when the line
198
     would overflow.  */
199
  for (p = format, i = 0, pos = 75; *p != 0; p++)
200
    if (*p != '0')
201
      {
202
        int ourlen = strlen (type_from_format (*p)) + 6 + (i > 9);
203
 
204
        printf (",");
205
        if (pos + ourlen > 76)
206
          printf ("\n\t\t\t\t      "), pos = 39;
207
 
208
        printf (" %sarg%d", type_from_format (*p), i++);
209
        pos += ourlen;
210
      }
211
  printf (" MEM_STAT_DECL");
212
 
213
  printf (");\n");
214
  printf ("#define gen_rtx_fmt_%s(c, m", format);
215
  for (p = format, i = 0; *p != 0; p++)
216
    if (*p != '0')
217
      printf (", p%i",i++);
218
  printf (")\\\n        gen_rtx_fmt_%s_stat (c, m", format);
219
  for (p = format, i = 0; *p != 0; p++)
220
    if (*p != '0')
221
      printf (", p%i",i++);
222
  printf (" MEM_STAT_INFO)\n\n");
223
}
224
 
225
/* Generate macros to generate RTL of code IDX using the functions we
226
   write.  */
227
 
228
static void
229
genmacro (int idx)
230
{
231
  const char *p;
232
  int i;
233
 
234
  /* We write a macro that defines gen_rtx_RTLCODE to be an equivalent to
235
     gen_rtx_fmt_FORMAT where FORMAT is the RTX_FORMAT of RTLCODE.  */
236
 
237
  if (excluded_rtx (idx))
238
    /* Don't define a macro for this code.  */
239
    return;
240
 
241
  printf ("#define gen_rtx_%s%s(MODE",
242
           special_rtx (idx) ? "raw_" : "", defs[idx].enumname);
243
 
244
  for (p = defs[idx].format, i = 0; *p != 0; p++)
245
    if (*p != '0')
246
      printf (", ARG%d", i++);
247
 
248
  printf (") \\\n  gen_rtx_fmt_%s (%s, (MODE)",
249
          defs[idx].format, defs[idx].enumname);
250
 
251
  for (p = defs[idx].format, i = 0; *p != 0; p++)
252
    if (*p != '0')
253
      printf (", (ARG%d)", i++);
254
 
255
  puts (")");
256
}
257
 
258
/* Generate the code for the function to generate RTL whose
259
   format is FORMAT.  */
260
 
261
static void
262
gendef (const char *format)
263
{
264
  const char *p;
265
  int i, j;
266
 
267
  /* Start by writing the definition of the function name and the types
268
     of the arguments.  */
269
 
270
  printf ("rtx\ngen_rtx_fmt_%s_stat (RTX_CODE code, enum machine_mode mode", format);
271
  for (p = format, i = 0; *p != 0; p++)
272
    if (*p != '0')
273
      printf (",\n\t%sarg%d", type_from_format (*p), i++);
274
 
275
  puts (" MEM_STAT_DECL)");
276
 
277
  /* Now write out the body of the function itself, which allocates
278
     the memory and initializes it.  */
279
  puts ("{");
280
  puts ("  rtx rt;");
281
  puts ("  rt = rtx_alloc_stat (code PASS_MEM_STAT);\n");
282
 
283
  puts ("  PUT_MODE (rt, mode);");
284
 
285
  for (p = format, i = j = 0; *p ; ++p, ++i)
286
    if (*p != '0')
287
      printf ("  %s (rt, %d) = arg%d;\n", accessor_from_format (*p), i, j++);
288
    else
289
      printf ("  X0EXP (rt, %d) = NULL_RTX;\n", i);
290
 
291
  puts ("\n  return rt;\n}\n");
292
}
293
 
294
/* Generate the documentation header for files we write.  */
295
 
296
static void
297
genlegend (void)
298
{
299
  puts ("/* Generated automatically by gengenrtl from rtl.def.  */\n");
300
}
301
 
302
/* Generate the text of the header file we make, genrtl.h.  */
303
 
304
static void
305
genheader (void)
306
{
307
  unsigned int i;
308
  const char **fmt;
309
 
310
  puts ("#ifndef GCC_GENRTL_H");
311
  puts ("#define GCC_GENRTL_H\n");
312
  puts ("#include \"statistics.h\"\n");
313
 
314
  for (fmt = formats; *fmt; ++fmt)
315
    gendecl (*fmt);
316
 
317
  putchar ('\n');
318
 
319
  for (i = 0; i < NUM_RTX_CODE; i++)
320
    if (! special_format (defs[i].format))
321
      genmacro (i);
322
 
323
  puts ("\n#endif /* GCC_GENRTL_H */");
324
}
325
 
326
/* Generate the text of the code file we write, genrtl.c.  */
327
 
328
static void
329
gencode (void)
330
{
331
  const char **fmt;
332
 
333
  puts ("#include \"config.h\"");
334
  puts ("#include \"system.h\"");
335
  puts ("#include \"coretypes.h\"");
336
  puts ("#include \"tm.h\"");
337
  puts ("#include \"obstack.h\"");
338
  puts ("#include \"rtl.h\"");
339
  puts ("#include \"ggc.h\"\n");
340
 
341
  for (fmt = formats; *fmt != 0; fmt++)
342
    gendef (*fmt);
343
}
344
 
345
/* This is the main program.  We accept only one argument, "-h", which
346
   says we are writing the genrtl.h file.  Otherwise we are writing the
347
   genrtl.c file.  */
348
 
349
int
350
main (int argc, char **argv)
351
{
352
  find_formats ();
353
  genlegend ();
354
 
355
  if (argc == 2 && argv[1][0] == '-' && argv[1][1] == 'h')
356
    genheader ();
357
  else
358
    gencode ();
359
 
360
  if (ferror (stdout) || fflush (stdout) || fclose (stdout))
361
    return FATAL_EXIT_CODE;
362
 
363
  return SUCCESS_EXIT_CODE;
364
}

powered by: WebSVN 2.1.0

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