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