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