gcc/genopinit.c

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