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

Subversion Repositories openrisc

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

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 38 julius
/* 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
}
161
 
162
/* Place a list of all format specifiers we use into the array FORMAT.  */
163
 
164
static void
165
find_formats (void)
166
{
167
  unsigned int i;
168
 
169
  for (i = 0; i < NUM_RTX_CODE; i++)
170
    {
171
      const char **f;
172
 
173
      if (special_format (defs[i].format))
174
        continue;
175
 
176
      for (f = formats; *f; f++)
177
        if (! strcmp (*f, defs[i].format))
178
          break;
179
 
180
      if (*f == 0)
181
        *f = defs[i].format;
182
    }
183
}
184
 
185
/* Write the declarations for the routine to allocate RTL with FORMAT.  */
186
 
187
static void
188
gendecl (const char *format)
189
{
190
  const char *p;
191
  int i, pos;
192
 
193
  printf ("extern rtx gen_rtx_fmt_%s\t (RTX_CODE, ", format);
194
  printf ("enum machine_mode mode");
195
 
196
  /* Write each parameter that is needed and start a new line when the line
197
     would overflow.  */
198
  for (p = format, i = 0, pos = 75; *p != 0; p++)
199
    if (*p != '0')
200
      {
201
        int ourlen = strlen (type_from_format (*p)) + 6 + (i > 9);
202
 
203
        printf (",");
204
        if (pos + ourlen > 76)
205
          printf ("\n\t\t\t\t      "), pos = 39;
206
 
207
        printf (" %sarg%d", type_from_format (*p), i++);
208
        pos += ourlen;
209
      }
210
 
211
  printf (");\n");
212
}
213
 
214
/* Generate macros to generate RTL of code IDX using the functions we
215
   write.  */
216
 
217
static void
218
genmacro (int idx)
219
{
220
  const char *p;
221
  int i;
222
 
223
  /* We write a macro that defines gen_rtx_RTLCODE to be an equivalent to
224
     gen_rtx_fmt_FORMAT where FORMAT is the RTX_FORMAT of RTLCODE.  */
225
 
226
  if (excluded_rtx (idx))
227
    /* Don't define a macro for this code.  */
228
    return;
229
 
230
  printf ("#define gen_rtx_%s%s(MODE",
231
           special_rtx (idx) ? "raw_" : "", defs[idx].enumname);
232
 
233
  for (p = defs[idx].format, i = 0; *p != 0; p++)
234
    if (*p != '0')
235
      printf (", ARG%d", i++);
236
 
237
  printf (") \\\n  gen_rtx_fmt_%s (%s, (MODE)",
238
          defs[idx].format, defs[idx].enumname);
239
 
240
  for (p = defs[idx].format, i = 0; *p != 0; p++)
241
    if (*p != '0')
242
      printf (", (ARG%d)", i++);
243
 
244
  puts (")");
245
}
246
 
247
/* Generate the code for the function to generate RTL whose
248
   format is FORMAT.  */
249
 
250
static void
251
gendef (const char *format)
252
{
253
  const char *p;
254
  int i, j;
255
 
256
  /* Start by writing the definition of the function name and the types
257
     of the arguments.  */
258
 
259
  printf ("rtx\ngen_rtx_fmt_%s (RTX_CODE code, enum machine_mode mode", format);
260
  for (p = format, i = 0; *p != 0; p++)
261
    if (*p != '0')
262
      printf (",\n\t%sarg%d", type_from_format (*p), i++);
263
 
264
  puts (")");
265
 
266
  /* Now write out the body of the function itself, which allocates
267
     the memory and initializes it.  */
268
  puts ("{");
269
  puts ("  rtx rt;");
270
  puts ("  rt = rtx_alloc (code);\n");
271
 
272
  puts ("  PUT_MODE (rt, mode);");
273
 
274
  for (p = format, i = j = 0; *p ; ++p, ++i)
275
    if (*p != '0')
276
      printf ("  %s (rt, %d) = arg%d;\n", accessor_from_format (*p), i, j++);
277
    else
278
      printf ("  X0EXP (rt, %d) = NULL_RTX;\n", i);
279
 
280
  puts ("\n  return rt;\n}\n");
281
}
282
 
283
/* Generate the documentation header for files we write.  */
284
 
285
static void
286
genlegend (void)
287
{
288
  puts ("/* Generated automatically by gengenrtl from rtl.def.  */\n");
289
}
290
 
291
/* Generate the text of the header file we make, genrtl.h.  */
292
 
293
static void
294
genheader (void)
295
{
296
  unsigned int i;
297
  const char **fmt;
298
 
299
  puts ("#ifndef GCC_GENRTL_H");
300
  puts ("#define GCC_GENRTL_H\n");
301
 
302
  for (fmt = formats; *fmt; ++fmt)
303
    gendecl (*fmt);
304
 
305
  putchar ('\n');
306
 
307
  for (i = 0; i < NUM_RTX_CODE; i++)
308
    if (! special_format (defs[i].format))
309
      genmacro (i);
310
 
311
  puts ("\n#endif /* GCC_GENRTL_H */");
312
}
313
 
314
/* Generate the text of the code file we write, genrtl.c.  */
315
 
316
static void
317
gencode (void)
318
{
319
  const char **fmt;
320
 
321
  puts ("#include \"config.h\"");
322
  puts ("#include \"system.h\"");
323
  puts ("#include \"coretypes.h\"");
324
  puts ("#include \"tm.h\"");
325
  puts ("#include \"obstack.h\"");
326
  puts ("#include \"rtl.h\"");
327
  puts ("#include \"ggc.h\"\n");
328
 
329
  for (fmt = formats; *fmt != 0; fmt++)
330
    gendef (*fmt);
331
}
332
 
333
/* This is the main program.  We accept only one argument, "-h", which
334
   says we are writing the genrtl.h file.  Otherwise we are writing the
335
   genrtl.c file.  */
336
 
337
int
338
main (int argc, char **argv)
339
{
340
  find_formats ();
341
  genlegend ();
342
 
343
  if (argc == 2 && argv[1][0] == '-' && argv[1][1] == 'h')
344
    genheader ();
345
  else
346
    gencode ();
347
 
348
  if (ferror (stdout) || fflush (stdout) || fclose (stdout))
349
    return FATAL_EXIT_CODE;
350
 
351
  return SUCCESS_EXIT_CODE;
352
}

powered by: WebSVN 2.1.0

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