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 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   "neg_optab->handlers[$A].insn_code = CODE_FOR_$(neg$P$a2$)",
 109   "negv_optab->handlers[(int) $A].insn_code =\n\
 110     neg_optab->handlers[(int) $A].insn_code = CODE_FOR_$(neg$F$a2$)",
 111   "negv_optab->handlers[(int) $A].insn_code = CODE_FOR_$(negv$I$a2$)",
 112   "abs_optab->handlers[$A].insn_code = CODE_FOR_$(abs$P$a2$)",
 113   "absv_optab->handlers[(int) $A].insn_code =\n\
 114     abs_optab->handlers[(int) $A].insn_code = CODE_FOR_$(abs$F$a2$)",
 115   "absv_optab->handlers[(int) $A].insn_code = CODE_FOR_$(absv$I$a2$)",
 116   "sqrt_optab->handlers[$A].insn_code = CODE_FOR_$(sqrt$a2$)",
 117   "floor_optab->handlers[$A].insn_code = CODE_FOR_$(floor$a2$)",
 118   "ceil_optab->handlers[$A].insn_code = CODE_FOR_$(ceil$a2$)",
 119   "round_optab->handlers[$A].insn_code = CODE_FOR_$(round$a2$)",
 120   "trunc_optab->handlers[$A].insn_code = CODE_FOR_$(trunc$a2$)",
 121   "nearbyint_optab->handlers[$A].insn_code = CODE_FOR_$(nearbyint$a2$)",
 122   "sin_optab->handlers[$A].insn_code = CODE_FOR_$(sin$a2$)",
 123   "cos_optab->handlers[$A].insn_code = CODE_FOR_$(cos$a2$)",
 124   "exp_optab->handlers[$A].insn_code = CODE_FOR_$(exp$a2$)",
 125   "log_optab->handlers[$A].insn_code = CODE_FOR_$(log$a2$)",
 126   "strlen_optab->handlers[$A].insn_code = CODE_FOR_$(strlen$a$)",
 127   "one_cmpl_optab->handlers[$A].insn_code = CODE_FOR_$(one_cmpl$a2$)",
 128   "ffs_optab->handlers[$A].insn_code = CODE_FOR_$(ffs$a2$)",
 129   "mov_optab->handlers[$A].insn_code = CODE_FOR_$(mov$a$)",
 130   "movstrict_optab->handlers[$A].insn_code = CODE_FOR_$(movstrict$a$)",
 131   "cmp_optab->handlers[$A].insn_code = CODE_FOR_$(cmp$a$)",
 132   "tst_optab->handlers[$A].insn_code = CODE_FOR_$(tst$a$)",
 133   "addcc_optab->handlers[$A].insn_code = CODE_FOR_$(add$acc$)",
 134   "bcc_gen_fctn[$C] = gen_$(b$c$)",
 135   "setcc_gen_code[$C] = CODE_FOR_$(s$c$)",
 136   "movcc_gen_code[$A] = CODE_FOR_$(mov$acc$)",
 137   "cbranch_optab->handlers[$A].insn_code = CODE_FOR_$(cbranch$a4$)",
 138   "cmov_optab->handlers[$A].insn_code = CODE_FOR_$(cmov$a6$)",
 139   "cstore_optab->handlers[$A].insn_code = CODE_FOR_$(cstore$a4$)",
 140   "push_optab->handlers[$A].insn_code = CODE_FOR_$(push$a1$)",
 141   "reload_in_optab[$A] = CODE_FOR_$(reload_in$a$)",
 142   "reload_out_optab[$A] = CODE_FOR_$(reload_out$a$)",
 143   "movstr_optab[$A] = CODE_FOR_$(movstr$a$)",
 144   "clrstr_optab[$A] = CODE_FOR_$(clrstr$a$)" };
 145
 146 static void gen_insn PARAMS ((rtx));
 147
 148 static void
 149 gen_insn (insn)
 150      rtx insn;
 151 {
 152   const char *name = XSTR (insn, 0);
 153   int m1 = 0, m2 = 0, op = 0;
 154   size_t pindex;
 155   int i;
 156   const char *np, *pp, *p, *q;
 157
 158   /* Don't mention instructions whose names are the null string.
 159      They are in the machine description just to be recognized.  */
 160   if (*name == 0)
 161     return;
 162
 163   /* See if NAME matches one of the patterns we have for the optabs we know
 164      about.  */
 165
 166   for (pindex = 0; pindex < ARRAY_SIZE (optabs); pindex++)
 167     {
 168       int force_float = 0, force_int = 0, force_partial_int = 0;
 169       int force_consec = 0;
 170       int matches = 1;
 171
 172       for (pp = optabs[pindex]; pp[0] != '$' || pp[1] != '('; pp++)
 173         ;
 174
 175       for (pp += 2, np = name; matches && ! (pp[0] == '$' && pp[1] == ')');
 176            pp++)
 177         {
 178           if (*pp != '$')
 179             {
 180               if (*pp != *np++)
 181                 break;
 182             }
 183           else
 184             switch (*++pp)
 185               {
 186               case 'N':
 187                 force_consec = 1;
 188                 break;
 189               case 'I':
 190                 force_int = 1;
 191                 break;
 192               case 'P':
 193                 force_partial_int = 1;
 194                 break;
 195               case 'F':
 196                 force_float = 1;
 197                 break;
 198               case 'V':
 199                 break;
 200               case 'c':
 201                 for (op = 0; op < NUM_RTX_CODE; op++)
 202                   {
 203                     for (p = GET_RTX_NAME(op), q = np; *p; p++, q++)
 204                       if (*p != *q)
 205                         break;
 206
 207                     /* We have to be concerned about matching "gt" and
 208                        missing "gtu", e.g., so verify we have reached the
 209                        end of thing we are to match.  */
 210                     if (*p == 0 && *q == 0 && GET_RTX_CLASS(op) == '<')
 211                       break;
 212                   }
 213
 214                 if (op == NUM_RTX_CODE)
 215                   matches = 0;
 216                 else
 217                   np += strlen (GET_RTX_NAME(op));
 218                 break;
 219               case 'a':
 220               case 'b':
 221                 /* This loop will stop at the first prefix match, so
 222                    look through the modes in reverse order, in case
 223                    EXTRA_CC_MODES was used and CC is a prefix of the
 224                    CC modes (as it should be).  */
 225                 for (i = ((int) MAX_MACHINE_MODE) - 1; i >= 0; i--)
 226                   {
 227                     for (p = GET_MODE_NAME(i), q = np; *p; p++, q++)
 228                       if (TOLOWER (*p) != *q)
 229                         break;
 230
 231                     if (*p == 0
 232                         && (! force_int || mode_class[i] == MODE_INT
 233                             || mode_class[i] == MODE_VECTOR_INT)
 234                         && (! force_partial_int
 235                             || mode_class[i] == MODE_INT
 236                             || mode_class[i] == MODE_PARTIAL_INT
 237                             || mode_class[i] == MODE_VECTOR_INT)
 238                         && (! force_float || mode_class[i] == MODE_FLOAT
 239                             || mode_class[i] == MODE_VECTOR_FLOAT))
 240                       break;
 241                   }
 242
 243                 if (i < 0)
 244                   matches = 0;
 245                 else if (*pp == 'a')
 246                   m1 = i, np += strlen (GET_MODE_NAME(i));
 247                 else
 248                   m2 = i, np += strlen (GET_MODE_NAME(i));
 249
 250                 force_int = force_partial_int = force_float = 0;
 251                 break;
 252
 253               default:
 254                 abort ();
 255               }
 256         }
 257
 258       if (matches && pp[0] == '$' && pp[1] == ')'
 259           && *np == 0
 260           && (! force_consec || (int) GET_MODE_WIDER_MODE(m1) == m2))
 261         break;
 262     }
 263
 264   if (pindex == ARRAY_SIZE (optabs))
 265     return;
 266
 267   /* We found a match.  If this pattern is only conditionally present,
 268      write out the "if" and two extra blanks.  */
 269
 270   if (*XSTR (insn, 2) != 0)
 271     printf ("  if (HAVE_%s)\n  ", name);
 272
 273   printf ("  ");
 274
 275   /* Now write out the initialization, making all required substitutions.  */
 276   for (pp = optabs[pindex]; *pp; pp++)
 277     {
 278       if (*pp != '$')
 279         putchar (*pp);
 280       else
 281         switch (*++pp)
 282           {
 283           case '(':  case ')':
 284           case 'I':  case 'F':  case 'N':
 285             break;
 286           case 'V':
 287             if (GET_MODE_CLASS (m1) == MODE_FLOAT)
 288               printf ("v");
 289             break;
 290           case 'a':
 291             for (np = GET_MODE_NAME(m1); *np; np++)
 292               putchar (TOLOWER (*np));
 293             break;
 294           case 'b':
 295             for (np = GET_MODE_NAME(m2); *np; np++)
 296               putchar (TOLOWER (*np));
 297             break;
 298           case 'A':
 299             printf ("(int) %smode", GET_MODE_NAME(m1));
 300             break;
 301           case 'B':
 302             printf ("(int) %smode", GET_MODE_NAME(m2));
 303             break;
 304           case 'c':
 305             printf ("%s", GET_RTX_NAME(op));
 306             break;
 307           case 'C':
 308             printf ("(int) ");
 309             for (np = GET_RTX_NAME(op); *np; np++)
 310               putchar (TOUPPER (*np));
 311             break;
 312           }
 313     }
 314
 315   printf (";\n");
 316 }
 317
 318 extern int main PARAMS ((int, char **));
 319
 320 int
 321 main (argc, argv)
 322      int argc;
 323      char **argv;
 324 {
 325   rtx desc;
 326
 327   progname = "genopinit";
 328
 329   if (argc <= 1)
 330     fatal ("no input file name");
 331
 332   if (init_md_reader_args (argc, argv) != SUCCESS_EXIT_CODE)
 333     return (FATAL_EXIT_CODE);
 334
 335   printf ("/* Generated automatically by the program `genopinit'\n\
 336 from the machine description file `md'.  */\n\n");
 337
 338   printf ("#include \"config.h\"\n");
 339   printf ("#include \"system.h\"\n");
 340   printf ("#include \"coretypes.h\"\n");
 341   printf ("#include \"tm.h\"\n");
 342   printf ("#include \"rtl.h\"\n");
 343   printf ("#include \"flags.h\"\n");
 344   printf ("#include \"insn-config.h\"\n");
 345   printf ("#include \"recog.h\"\n");
 346   printf ("#include \"expr.h\"\n");
 347   printf ("#include \"optabs.h\"\n");
 348   printf ("#include \"reload.h\"\n\n");
 349
 350   printf ("void\ninit_all_optabs ()\n{\n");
 351
 352   /* Read the machine description.  */
 353
 354   while (1)
 355     {
 356       int line_no, insn_code_number = 0;
 357
 358       desc = read_md_rtx (&line_no, &insn_code_number);
 359       if (desc == NULL)
 360         break;
 361
 362       if (GET_CODE (desc) == DEFINE_INSN || GET_CODE (desc) == DEFINE_EXPAND)
 363         gen_insn (desc);
 364     }
 365
 366   printf ("}\n");
 367
 368   fflush (stdout);
 369   return (ferror (stdout) != 0 ? FATAL_EXIT_CODE : SUCCESS_EXIT_CODE);
 370 }
 371
 372 /* Define this so we can link with print-rtl.o to get debug_rtx function.  */
 373 const char *
 374 get_insn_name (code)
 375      int code ATTRIBUTE_UNUSED;
 376 {
 377   return NULL;
 378 }