genflags.c revision 132718 
1/* Generate from machine description:
2   - some flags HAVE_... saying which simple standard instructions are
3   available for this machine.
4   Copyright (C) 1987, 1991, 1995, 1998,
5   1999, 2000, 2003, 2004 Free Software Foundation, Inc.
6
7This file is part of GCC.
8
9GCC is free software; you can redistribute it and/or modify it under
10the terms of the GNU General Public License as published by the Free
11Software Foundation; either version 2, or (at your option) any later
12version.
13
14GCC is distributed in the hope that it will be useful, but WITHOUT ANY
15WARRANTY; without even the implied warranty of MERCHANTABILITY or
16FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
17for more details.
18
19You should have received a copy of the GNU General Public License
20along with GCC; see the file COPYING.  If not, write to the Free
21Software Foundation, 59 Temple Place - Suite 330, Boston, MA
2202111-1307, USA.  */
23
24
25#include "bconfig.h"
26#include "system.h"
27#include "coretypes.h"
28#include "tm.h"
29#include "rtl.h"
30#include "obstack.h"
31#include "errors.h"
32#include "gensupport.h"
33
34/* Obstack to remember insns with.  */
35static struct obstack obstack;
36
37/* Max size of names encountered.  */
38static int max_id_len;
39
40/* Max operand encountered in a scan over some insn.  */
41static int max_opno;
42
43static void max_operand_1 (rtx);
44static int num_operands (rtx);
45static void gen_proto (rtx);
46static void gen_macro (const char *, int, int);
47static void gen_insn (rtx);
48
49/* Count the number of match_operand's found.  */
50
51static void
52max_operand_1 (rtx x)
53{
54  RTX_CODE code;
55  int i;
56  int len;
57  const char *fmt;
58
59  if (x == 0)
60    return;
61
62  code = GET_CODE (x);
63
64  if (code == MATCH_OPERAND || code == MATCH_OPERATOR
65      || code == MATCH_PARALLEL)
66    max_opno = MAX (max_opno, XINT (x, 0));
67
68  fmt = GET_RTX_FORMAT (code);
69  len = GET_RTX_LENGTH (code);
70  for (i = 0; i < len; i++)
71    {
72      if (fmt[i] == 'e' || fmt[i] == 'u')
73	max_operand_1 (XEXP (x, i));
74      else if (fmt[i] == 'E')
75	{
76	  int j;
77	  for (j = 0; j < XVECLEN (x, i); j++)
78	    max_operand_1 (XVECEXP (x, i, j));
79	}
80    }
81}
82
83static int
84num_operands (rtx insn)
85{
86  int len = XVECLEN (insn, 1);
87  int i;
88
89  max_opno = -1;
90
91  for (i = 0; i < len; i++)
92    max_operand_1 (XVECEXP (insn, 1, i));
93
94  return max_opno + 1;
95}
96
97/* Print out a wrapper macro for a function which corrects the number
98   of arguments it takes.  Any missing arguments are assumed to be at
99   the end.  */
100static void
101gen_macro (const char *name, int real, int expect)
102{
103  int i;
104
105  if (real > expect)
106    abort ();
107  if (real == 0)
108    abort ();
109
110  /* #define GEN_CALL(A, B, C, D) gen_call((A), (B)) */
111  fputs ("#define GEN_", stdout);
112  for (i = 0; name[i]; i++)
113    putchar (TOUPPER (name[i]));
114
115  putchar('(');
116  for (i = 0; i < expect - 1; i++)
117    printf ("%c, ", i + 'A');
118  printf ("%c) gen_%s (", i + 'A', name);
119
120  for (i = 0; i < real - 1; i++)
121    printf ("(%c), ", i + 'A');
122  printf ("(%c))\n", i + 'A');
123}
124
125/* Print out prototype information for a generator function.  If the
126   insn pattern has been elided, print out a dummy generator that
127   does nothing.  */
128
129static void
130gen_proto (rtx insn)
131{
132  int num = num_operands (insn);
133  int i;
134  const char *name = XSTR (insn, 0);
135  int truth = maybe_eval_c_test (XSTR (insn, 2));
136
137  /* Many md files don't refer to the last two operands passed to the
138     call patterns.  This means their generator functions will be two
139     arguments too short.  Instead of changing every md file to touch
140     those operands, we wrap the prototypes in macros that take the
141     correct number of arguments.  */
142  if (name[0] == 'c' || name[0] == 's')
143    {
144      if (!strcmp (name, "call")
145	  || !strcmp (name, "call_pop")
146	  || !strcmp (name, "sibcall")
147	  || !strcmp (name, "sibcall_pop"))
148	gen_macro (name, num, 4);
149      else if (!strcmp (name, "call_value")
150	       || !strcmp (name, "call_value_pop")
151	       || !strcmp (name, "sibcall_value")
152	       || !strcmp (name, "sibcall_value_pop"))
153	gen_macro (name, num, 5);
154    }
155
156  if (truth != 0)
157    printf ("extern rtx        gen_%-*s (", max_id_len, name);
158  else
159    printf ("static inline rtx gen_%-*s (", max_id_len, name);
160
161  if (num == 0)
162    fputs ("void", stdout);
163  else
164    {
165      for (i = 1; i < num; i++)
166	fputs ("rtx, ", stdout);
167
168      fputs ("rtx", stdout);
169    }
170
171  puts (");");
172
173  /* Some back ends want to take the address of generator functions,
174     so we cannot simply use #define for these dummy definitions.  */
175  if (truth == 0)
176    {
177      printf ("static inline rtx\ngen_%s", name);
178      if (num > 0)
179	{
180	  putchar ('(');
181	  for (i = 0; i < num-1; i++)
182	    printf ("rtx %c ATTRIBUTE_UNUSED, ", 'a' + i);
183	  printf ("rtx %c ATTRIBUTE_UNUSED)\n", 'a' + i);
184	}
185      else
186	puts ("(void)");
187      puts ("{\n  return 0;\n}");
188    }
189
190}
191
192static void
193gen_insn (rtx insn)
194{
195  const char *name = XSTR (insn, 0);
196  const char *p;
197  int len;
198  int truth = maybe_eval_c_test (XSTR (insn, 2));
199
200  /* Don't mention instructions whose names are the null string
201     or begin with '*'.  They are in the machine description just
202     to be recognized.  */
203  if (name[0] == 0 || name[0] == '*')
204    return;
205
206  len = strlen (name);
207
208  if (len > max_id_len)
209    max_id_len = len;
210
211  if (truth == 0)
212    /* Emit nothing.  */;
213  else if (truth == 1)
214    printf ("#define HAVE_%s 1\n", name);
215  else
216    {
217      /* Write the macro definition, putting \'s at the end of each line,
218	 if more than one.  */
219      printf ("#define HAVE_%s (", name);
220      for (p = XSTR (insn, 2); *p; p++)
221	{
222	  if (IS_VSPACE (*p))
223	    fputs (" \\\n", stdout);
224	  else
225	    putchar (*p);
226	}
227      fputs (")\n", stdout);
228    }
229
230  obstack_grow (&obstack, &insn, sizeof (rtx));
231}
232
233int
234main (int argc, char **argv)
235{
236  rtx desc;
237  rtx dummy;
238  rtx *insns;
239  rtx *insn_ptr;
240
241  progname = "genflags";
242  obstack_init (&obstack);
243
244  /* We need to see all the possibilities.  Elided insns may have
245     direct calls to their generators in C code.  */
246  insn_elision = 0;
247
248  if (argc <= 1)
249    fatal ("no input file name");
250
251  if (init_md_reader_args (argc, argv) != SUCCESS_EXIT_CODE)
252    return (FATAL_EXIT_CODE);
253
254  puts ("/* Generated automatically by the program `genflags'");
255  puts ("   from the machine description file `md'.  */\n");
256  puts ("#ifndef GCC_INSN_FLAGS_H");
257  puts ("#define GCC_INSN_FLAGS_H\n");
258
259  /* Read the machine description.  */
260
261  while (1)
262    {
263      int line_no, insn_code_number = 0;
264
265      desc = read_md_rtx (&line_no, &insn_code_number);
266      if (desc == NULL)
267	break;
268      if (GET_CODE (desc) == DEFINE_INSN || GET_CODE (desc) == DEFINE_EXPAND)
269	gen_insn (desc);
270    }
271
272  /* Print out the prototypes now.  */
273  dummy = (rtx) 0;
274  obstack_grow (&obstack, &dummy, sizeof (rtx));
275  insns = (rtx *) obstack_finish (&obstack);
276
277  for (insn_ptr = insns; *insn_ptr; insn_ptr++)
278    gen_proto (*insn_ptr);
279
280  puts("\n#endif /* GCC_INSN_FLAGS_H */");
281
282  if (ferror (stdout) || fflush (stdout) || fclose (stdout))
283    return FATAL_EXIT_CODE;
284
285  return SUCCESS_EXIT_CODE;
286}
287
288/* Define this so we can link with print-rtl.o to get debug_rtx function.  */
289const char *
290get_insn_name (int code ATTRIBUTE_UNUSED)
291{
292  return NULL;
293}
294