gcc/genflags.c

   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, 1999, 2000, 2003, 2004, 2007
   5    Free Software Foundation, Inc.
   6
   7 This file is part of GCC.
   8
   9 GCC is free software; you can redistribute it and/or modify it under
  10 the terms of the GNU General Public License as published by the Free
  11 Software Foundation; either version 3, or (at your option) any later
  12 version.
  13
  14 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  15 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  16 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  17 for more details.
  18
  19 You should have received a copy of the GNU General Public License
  20 along with GCC; see the file COPYING3.  If not see
  21 <http://www.gnu.org/licenses/>.  */
  22
  23
  24 #include "bconfig.h"
  25 #include "system.h"
  26 #include "coretypes.h"
  27 #include "tm.h"
  28 #include "rtl.h"
  29 #include "obstack.h"
  30 #include "errors.h"
  31 #include "gensupport.h"
  32
  33 /* Obstack to remember insns with.  */
  34 static struct obstack obstack;
  35
  36 /* Max size of names encountered.  */
  37 static int max_id_len;
  38
  39 /* Max operand encountered in a scan over some insn.  */
  40 static int max_opno;
  41
  42 static void max_operand_1 (rtx);
  43 static int num_operands (rtx);
  44 static void gen_proto (rtx);
  45 static void gen_macro (const char *, int, int);
  46 static void gen_insn (int, rtx);
  47
  48 /* Count the number of match_operand's found.  */
  49
  50 static void
  51 max_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
  82 static int
  83 num_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.  */
  99 static void
 100 gen_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
 126 static void
 127 gen_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
 189 static void
 190 gen_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
 249 int
 250 main (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_md_reader_args (argc, argv) != SUCCESS_EXIT_CODE)
 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 }