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