gcc/genopinit.c

   1 /* Generate code to initialize optabs from machine description.
   2    Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998,
   3    1999, 2000 Free Software Foundation, Inc.
   4
   5 This file is part of GNU CC.
   6
   7 GNU CC is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2, or (at your option)
  10 any later version.
  11
  12 GNU CC is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GNU CC; see the file COPYING.  If not, write to
  19 the Free Software Foundation, 59 Temple Place - Suite 330,
  20 Boston, MA 02111-1307, USA.  */
  21
  22
  23 #include "hconfig.h"
  24 #include "system.h"
  25 #include "rtl.h"
  26 #include "errors.h"
  27 #include "gensupport.h"
  28
  29
  30 /* Many parts of GCC use arrays that are indexed by machine mode and
  31    contain the insn codes for pattern in the MD file that perform a given
  32    operation on operands of that mode.
  33
  34    These patterns are present in the MD file with names that contain
  35    the mode(s) used and the name of the operation.  This program
  36    writes a function `init_all_optabs' that initializes the optabs with
  37    all the insn codes of the relevant patterns present in the MD file.
  38
  39    This array contains a list of optabs that need to be initialized.  Within
  40    each string, the name of the pattern to be matched against is delimited
  41    with $( and $).  In the string, $a and $b are used to match a short mode
  42    name (the part of the mode name not including `mode' and converted to
  43    lower-case).  When writing out the initializer, the entire string is
  44    used.  $A and $B are replaced with the full name of the mode; $a and $b
  45    are replaced with the short form of the name, as above.
  46
  47    If $N is present in the pattern, it means the two modes must be consecutive
  48    widths in the same mode class (e.g, QImode and HImode).  $I means that
  49    only full integer modes should be considered for the next mode, and $F
  50    means that only float modes should be considered.
  51    $P means that both full and partial integer modes should be considered.
  52
  53    $V means to emit 'v' if the first mode is a MODE_FLOAT mode.
  54
  55    For some optabs, we store the operation by RTL codes.  These are only
  56    used for comparisons.  In that case, $c and $C are the lower-case and
  57    upper-case forms of the comparison, respectively.  */
  58
  59 const char * const optabs[] =
  60 { "extendtab[$B][$A][0] = CODE_FOR_$(extend$a$b2$)",
  61   "extendtab[$B][$A][1] = CODE_FOR_$(zero_extend$a$b2$)",
  62   "fixtab[$A][$B][0] = CODE_FOR_$(fix$F$a$I$b2$)",
  63   "fixtab[$A][$B][1] = CODE_FOR_$(fixuns$F$a$b2$)",
  64   "fixtrunctab[$A][$B][0] = CODE_FOR_$(fix_trunc$F$a$I$b2$)",
  65   "fixtrunctab[$A][$B][1] = CODE_FOR_$(fixuns_trunc$F$a$I$b2$)",
  66   "floattab[$B][$A][0] = CODE_FOR_$(float$I$a$F$b2$)",
  67   "floattab[$B][$A][1] = CODE_FOR_$(floatuns$I$a$F$b2$)",
  68   "add_optab->handlers[$A].insn_code = CODE_FOR_$(add$P$a3$)",
  69   "addv_optab->handlers[(int) $A].insn_code =\n\
  70     add_optab->handlers[(int) $A].insn_code = CODE_FOR_$(add$F$a3$)",
  71   "addv_optab->handlers[(int) $A].insn_code = CODE_FOR_$(addv$I$a3$)",
  72   "sub_optab->handlers[$A].insn_code = CODE_FOR_$(sub$P$a3$)",
  73   "subv_optab->handlers[(int) $A].insn_code =\n\
  74     sub_optab->handlers[(int) $A].insn_code = CODE_FOR_$(sub$F$a3$)",
  75   "subv_optab->handlers[(int) $A].insn_code = CODE_FOR_$(subv$I$a3$)",
  76   "smul_optab->handlers[$A].insn_code = CODE_FOR_$(mul$P$a3$)",
  77   "smulv_optab->handlers[(int) $A].insn_code =\n\
  78     smul_optab->handlers[(int) $A].insn_code = CODE_FOR_$(mul$F$a3$)",
  79   "smulv_optab->handlers[(int) $A].insn_code = CODE_FOR_$(mulv$I$a3$)",
  80   "umul_highpart_optab->handlers[$A].insn_code = CODE_FOR_$(umul$a3_highpart$)",
  81   "smul_highpart_optab->handlers[$A].insn_code = CODE_FOR_$(smul$a3_highpart$)",
  82   "smul_widen_optab->handlers[$B].insn_code = CODE_FOR_$(mul$a$b3$)$N",
  83   "umul_widen_optab->handlers[$B].insn_code = CODE_FOR_$(umul$a$b3$)$N",
  84   "sdiv_optab->handlers[$A].insn_code = CODE_FOR_$(div$I$a3$)",
  85   "sdivv_optab->handlers[(int) $A].insn_code = CODE_FOR_$(div$V$I$a3$)",
  86   "udiv_optab->handlers[$A].insn_code = CODE_FOR_$(udiv$I$a3$)",
  87   "sdivmod_optab->handlers[$A].insn_code = CODE_FOR_$(divmod$a4$)",
  88   "udivmod_optab->handlers[$A].insn_code = CODE_FOR_$(udivmod$a4$)",
  89   "smod_optab->handlers[$A].insn_code = CODE_FOR_$(mod$a3$)",
  90   "umod_optab->handlers[$A].insn_code = CODE_FOR_$(umod$a3$)",
  91   "flodiv_optab->handlers[$A].insn_code = CODE_FOR_$(div$F$a3$)",
  92   "ftrunc_optab->handlers[$A].insn_code = CODE_FOR_$(ftrunc$F$a2$)",
  93   "and_optab->handlers[$A].insn_code = CODE_FOR_$(and$a3$)",
  94   "ior_optab->handlers[$A].insn_code = CODE_FOR_$(ior$a3$)",
  95   "xor_optab->handlers[$A].insn_code = CODE_FOR_$(xor$a3$)",
  96   "ashl_optab->handlers[$A].insn_code = CODE_FOR_$(ashl$a3$)",
  97   "ashr_optab->handlers[$A].insn_code = CODE_FOR_$(ashr$a3$)",
  98   "lshr_optab->handlers[$A].insn_code = CODE_FOR_$(lshr$a3$)",
  99   "rotl_optab->handlers[$A].insn_code = CODE_FOR_$(rotl$a3$)",
 100   "rotr_optab->handlers[$A].insn_code = CODE_FOR_$(rotr$a3$)",
 101   "smin_optab->handlers[$A].insn_code = CODE_FOR_$(smin$I$a3$)",
 102   "smin_optab->handlers[$A].insn_code = CODE_FOR_$(min$F$a3$)",
 103   "smax_optab->handlers[$A].insn_code = CODE_FOR_$(smax$I$a3$)",
 104   "smax_optab->handlers[$A].insn_code = CODE_FOR_$(max$F$a3$)",
 105   "umin_optab->handlers[$A].insn_code = CODE_FOR_$(umin$I$a3$)",
 106   "umax_optab->handlers[$A].insn_code = CODE_FOR_$(umax$I$a3$)",
 107   "neg_optab->handlers[$A].insn_code = CODE_FOR_$(neg$P$a2$)",
 108   "negv_optab->handlers[(int) $A].insn_code =\n\
 109     neg_optab->handlers[(int) $A].insn_code = CODE_FOR_$(neg$F$a2$)",
 110   "negv_optab->handlers[(int) $A].insn_code = CODE_FOR_$(negv$I$a2$)",
 111   "abs_optab->handlers[$A].insn_code = CODE_FOR_$(abs$P$a2$)",
 112   "absv_optab->handlers[(int) $A].insn_code =\n\
 113     abs_optab->handlers[(int) $A].insn_code = CODE_FOR_$(abs$F$a2$)",
 114   "absv_optab->handlers[(int) $A].insn_code = CODE_FOR_$(absv$I$a2$)",
 115   "sqrt_optab->handlers[$A].insn_code = CODE_FOR_$(sqrt$a2$)",
 116   "sin_optab->handlers[$A].insn_code = CODE_FOR_$(sin$a2$)",
 117   "cos_optab->handlers[$A].insn_code = CODE_FOR_$(cos$a2$)",
 118   "strlen_optab->handlers[$A].insn_code = CODE_FOR_$(strlen$a$)",
 119   "one_cmpl_optab->handlers[$A].insn_code = CODE_FOR_$(one_cmpl$a2$)",
 120   "ffs_optab->handlers[$A].insn_code = CODE_FOR_$(ffs$a2$)",
 121   "mov_optab->handlers[$A].insn_code = CODE_FOR_$(mov$a$)",
 122   "movstrict_optab->handlers[$A].insn_code = CODE_FOR_$(movstrict$a$)",
 123   "cmp_optab->handlers[$A].insn_code = CODE_FOR_$(cmp$a$)",
 124   "tst_optab->handlers[$A].insn_code = CODE_FOR_$(tst$a$)",
 125   "bcc_gen_fctn[$C] = gen_$(b$c$)",
 126   "setcc_gen_code[$C] = CODE_FOR_$(s$c$)",
 127   "movcc_gen_code[$A] = CODE_FOR_$(mov$acc$)",
 128   "cbranch_optab->handlers[$A].insn_code = CODE_FOR_$(cbranch$a4$)",
 129   "cmov_optab->handlers[$A].insn_code = CODE_FOR_$(cmov$a6$)",
 130   "cstore_optab->handlers[$A].insn_code = CODE_FOR_$(cstore$a4$)",
 131   "push_optab->handlers[$A].insn_code = CODE_FOR_$(push$a1$)",
 132   "reload_in_optab[$A] = CODE_FOR_$(reload_in$a$)",
 133   "reload_out_optab[$A] = CODE_FOR_$(reload_out$a$)",
 134   "movstr_optab[$A] = CODE_FOR_$(movstr$a$)",
 135   "clrstr_optab[$A] = CODE_FOR_$(clrstr$a$)" };
 136
 137 static void gen_insn PARAMS ((rtx));
 138
 139 static void
 140 gen_insn (insn)
 141      rtx insn;
 142 {
 143   const char *name = XSTR (insn, 0);
 144   int m1 = 0, m2 = 0, op = 0;
 145   size_t pindex;
 146   int i;
 147   const char *np, *pp, *p, *q;
 148
 149   /* Don't mention instructions whose names are the null string.
 150      They are in the machine description just to be recognized.  */
 151   if (*name == 0)
 152     return;
 153
 154   /* See if NAME matches one of the patterns we have for the optabs we know
 155      about.  */
 156
 157   for (pindex = 0; pindex < ARRAY_SIZE (optabs); pindex++)
 158     {
 159       int force_float = 0, force_int = 0, force_partial_int = 0;
 160       int force_consec = 0;
 161       int matches = 1;
 162
 163       for (pp = optabs[pindex]; pp[0] != '$' || pp[1] != '('; pp++)
 164         ;
 165
 166       for (pp += 2, np = name; matches && ! (pp[0] == '$' && pp[1] == ')');
 167            pp++)
 168         {
 169           if (*pp != '$')
 170             {
 171               if (*pp != *np++)
 172                 break;
 173             }
 174           else
 175             switch (*++pp)
 176               {
 177               case 'N':
 178                 force_consec = 1;
 179                 break;
 180               case 'I':
 181                 force_int = 1;
 182                 break;
 183               case 'P':
 184                 force_partial_int = 1;
 185                 break;
 186               case 'F':
 187                 force_float = 1;
 188                 break;
 189               case 'V':
 190                 break;
 191               case 'c':
 192                 for (op = 0; op < NUM_RTX_CODE; op++)
 193                   {
 194                     for (p = GET_RTX_NAME(op), q = np; *p; p++, q++)
 195                       if (*p != *q)
 196                         break;
 197
 198                     /* We have to be concerned about matching "gt" and
 199                        missing "gtu", e.g., so verify we have reached the
 200                        end of thing we are to match.  */
 201                     if (*p == 0 && *q == 0 && GET_RTX_CLASS(op) == '<')
 202                       break;
 203                   }
 204
 205                 if (op == NUM_RTX_CODE)
 206                   matches = 0;
 207                 else
 208                   np += strlen (GET_RTX_NAME(op));
 209                 break;
 210               case 'a':
 211               case 'b':
 212                 /* This loop will stop at the first prefix match, so
 213                    look through the modes in reverse order, in case
 214                    EXTRA_CC_MODES was used and CC is a prefix of the
 215                    CC modes (as it should be).  */
 216                 for (i = ((int) MAX_MACHINE_MODE) - 1; i >= 0; i--)
 217                   {
 218                     for (p = GET_MODE_NAME(i), q = np; *p; p++, q++)
 219                       if (TOLOWER (*p) != *q)
 220                         break;
 221
 222                     if (*p == 0
 223                         && (! force_int || mode_class[i] == MODE_INT)
 224                         && (! force_partial_int
 225                             || mode_class[i] == MODE_INT
 226                             || mode_class[i] == MODE_PARTIAL_INT)
 227                         && (! force_float || mode_class[i] == MODE_FLOAT))
 228                       break;
 229                   }
 230
 231                 if (i < 0)
 232                   matches = 0;
 233                 else if (*pp == 'a')
 234                   m1 = i, np += strlen (GET_MODE_NAME(i));
 235                 else
 236                   m2 = i, np += strlen (GET_MODE_NAME(i));
 237
 238                 force_int = force_partial_int = force_float = 0;
 239                 break;
 240
 241               default:
 242                 abort ();
 243               }
 244         }
 245
 246       if (matches && pp[0] == '$' && pp[1] == ')'
 247           && *np == 0
 248           && (! force_consec || (int) GET_MODE_WIDER_MODE(m1) == m2))
 249         break;
 250     }
 251
 252   if (pindex == ARRAY_SIZE (optabs))
 253     return;
 254
 255   /* We found a match.  If this pattern is only conditionally present,
 256      write out the "if" and two extra blanks.  */
 257
 258   if (*XSTR (insn, 2) != 0)
 259     printf ("  if (HAVE_%s)\n  ", name);
 260
 261   printf ("  ");
 262
 263   /* Now write out the initialization, making all required substitutions.  */
 264   for (pp = optabs[pindex]; *pp; pp++)
 265     {
 266       if (*pp != '$')
 267         putchar (*pp);
 268       else
 269         switch (*++pp)
 270           {
 271           case '(':  case ')':
 272           case 'I':  case 'F':  case 'N':
 273             break;
 274           case 'V':
 275             if (GET_MODE_CLASS (m1) == MODE_FLOAT)
 276               printf ("v");
 277             break;
 278           case 'a':
 279             for (np = GET_MODE_NAME(m1); *np; np++)
 280               putchar (TOLOWER (*np));
 281             break;
 282           case 'b':
 283             for (np = GET_MODE_NAME(m2); *np; np++)
 284               putchar (TOLOWER (*np));
 285             break;
 286           case 'A':
 287             printf ("(int) %smode", GET_MODE_NAME(m1));
 288             break;
 289           case 'B':
 290             printf ("(int) %smode", GET_MODE_NAME(m2));
 291             break;
 292           case 'c':
 293             printf ("%s", GET_RTX_NAME(op));
 294             break;
 295           case 'C':
 296             printf ("(int) ");
 297             for (np = GET_RTX_NAME(op); *np; np++)
 298               putchar (TOUPPER (*np));
 299             break;
 300           }
 301     }
 302
 303   printf (";\n");
 304 }
 305
 306 extern int main PARAMS ((int, char **));
 307
 308 int
 309 main (argc, argv)
 310      int argc;
 311      char **argv;
 312 {
 313   rtx desc;
 314
 315   progname = "genopinit";
 316
 317   if (argc <= 1)
 318     fatal ("No input file name.");
 319
 320   if (init_md_reader (argv[1]) != SUCCESS_EXIT_CODE)
 321     return (FATAL_EXIT_CODE);
 322
 323   printf ("/* Generated automatically by the program `genopinit'\n\
 324 from the machine description file `md'.  */\n\n");
 325
 326   printf ("#include \"config.h\"\n");
 327   printf ("#include \"system.h\"\n");
 328   printf ("#include \"rtl.h\"\n");
 329   printf ("#include \"flags.h\"\n");
 330   printf ("#include \"insn-config.h\"\n");
 331   printf ("#include \"recog.h\"\n");
 332   printf ("#include \"expr.h\"\n");
 333   printf ("#include \"reload.h\"\n\n");
 334
 335   printf ("void\ninit_all_optabs ()\n{\n");
 336
 337   /* Read the machine description.  */
 338
 339   while (1)
 340     {
 341       int line_no, insn_code_number = 0;
 342
 343       desc = read_md_rtx (&line_no, &insn_code_number);
 344       if (desc == NULL)
 345         break;
 346
 347       if (GET_CODE (desc) == DEFINE_INSN || GET_CODE (desc) == DEFINE_EXPAND)
 348         gen_insn (desc);
 349     }
 350
 351   printf ("}\n");
 352
 353   fflush (stdout);
 354   return (ferror (stdout) != 0 ? FATAL_EXIT_CODE : SUCCESS_EXIT_CODE);
 355 }
 356
 357 /* Define this so we can link with print-rtl.o to get debug_rtx function.  */
 358 const char *
 359 get_insn_name (code)
 360      int code ATTRIBUTE_UNUSED;
 361 {
 362   return NULL;
 363 }