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 { "sext_optab->handlers[$B][$A].insn_code = CODE_FOR_$(extend$a$b2$)",
  63   "zext_optab->handlers[$B][$A].insn_code = CODE_FOR_$(zero_extend$a$b2$)",
  64   "sfix_optab->handlers[$B][$A].insn_code = CODE_FOR_$(fix$F$a$I$b2$)",
  65   "ufix_optab->handlers[$B][$A].insn_code = CODE_FOR_$(fixuns$F$a$b2$)",
  66   "sfixtrunc_optab->handlers[$B][$A].insn_code = CODE_FOR_$(fix_trunc$F$a$I$b2$)",
  67   "ufixtrunc_optab->handlers[$B][$A].insn_code = CODE_FOR_$(fixuns_trunc$F$a$I$b2$)",
  68   "sfloat_optab->handlers[$B][$A].insn_code = CODE_FOR_$(float$I$a$F$b2$)",
  69   "ufloat_optab->handlers[$B][$A].insn_code = CODE_FOR_$(floatuns$I$a$F$b2$)",
  70   "trunc_optab->handlers[$B][$A].insn_code = CODE_FOR_$(trunc$a$b2$)",
  71   "add_optab->handlers[$A].insn_code = CODE_FOR_$(add$P$a3$)",
  72   "addv_optab->handlers[$A].insn_code =\n\
  73     add_optab->handlers[$A].insn_code = CODE_FOR_$(add$F$a3$)",
  74   "addv_optab->handlers[$A].insn_code = CODE_FOR_$(addv$I$a3$)",
  75   "sub_optab->handlers[$A].insn_code = CODE_FOR_$(sub$P$a3$)",
  76   "subv_optab->handlers[$A].insn_code =\n\
  77     sub_optab->handlers[$A].insn_code = CODE_FOR_$(sub$F$a3$)",
  78   "subv_optab->handlers[$A].insn_code = CODE_FOR_$(subv$I$a3$)",
  79   "smul_optab->handlers[$A].insn_code = CODE_FOR_$(mul$P$a3$)",
  80   "smulv_optab->handlers[$A].insn_code =\n\
  81     smul_optab->handlers[$A].insn_code = CODE_FOR_$(mul$F$a3$)",
  82   "smulv_optab->handlers[$A].insn_code = CODE_FOR_$(mulv$I$a3$)",
  83   "umul_highpart_optab->handlers[$A].insn_code = CODE_FOR_$(umul$a3_highpart$)",
  84   "smul_highpart_optab->handlers[$A].insn_code = CODE_FOR_$(smul$a3_highpart$)",
  85   "smul_widen_optab->handlers[$B].insn_code = CODE_FOR_$(mul$a$b3$)$N",
  86   "umul_widen_optab->handlers[$B].insn_code = CODE_FOR_$(umul$a$b3$)$N",
  87   "sdiv_optab->handlers[$A].insn_code = CODE_FOR_$(div$a3$)",
  88   "sdivv_optab->handlers[$A].insn_code = CODE_FOR_$(div$V$I$a3$)",
  89   "udiv_optab->handlers[$A].insn_code = CODE_FOR_$(udiv$I$a3$)",
  90   "sdivmod_optab->handlers[$A].insn_code = CODE_FOR_$(divmod$a4$)",
  91   "udivmod_optab->handlers[$A].insn_code = CODE_FOR_$(udivmod$a4$)",
  92   "smod_optab->handlers[$A].insn_code = CODE_FOR_$(mod$a3$)",
  93   "umod_optab->handlers[$A].insn_code = CODE_FOR_$(umod$a3$)",
  94   "ftrunc_optab->handlers[$A].insn_code = CODE_FOR_$(ftrunc$F$a2$)",
  95   "and_optab->handlers[$A].insn_code = CODE_FOR_$(and$a3$)",
  96   "ior_optab->handlers[$A].insn_code = CODE_FOR_$(ior$a3$)",
  97   "xor_optab->handlers[$A].insn_code = CODE_FOR_$(xor$a3$)",
  98   "ashl_optab->handlers[$A].insn_code = CODE_FOR_$(ashl$a3$)",
  99   "ashr_optab->handlers[$A].insn_code = CODE_FOR_$(ashr$a3$)",
 100   "lshr_optab->handlers[$A].insn_code = CODE_FOR_$(lshr$a3$)",
 101   "rotl_optab->handlers[$A].insn_code = CODE_FOR_$(rotl$a3$)",
 102   "rotr_optab->handlers[$A].insn_code = CODE_FOR_$(rotr$a3$)",
 103   "smin_optab->handlers[$A].insn_code = CODE_FOR_$(smin$I$a3$)",
 104   "smin_optab->handlers[$A].insn_code = CODE_FOR_$(min$F$a3$)",
 105   "smax_optab->handlers[$A].insn_code = CODE_FOR_$(smax$I$a3$)",
 106   "smax_optab->handlers[$A].insn_code = CODE_FOR_$(max$F$a3$)",
 107   "umin_optab->handlers[$A].insn_code = CODE_FOR_$(umin$I$a3$)",
 108   "umax_optab->handlers[$A].insn_code = CODE_FOR_$(umax$I$a3$)",
 109   "pow_optab->handlers[$A].insn_code = CODE_FOR_$(pow$a3$)",
 110   "atan2_optab->handlers[$A].insn_code = CODE_FOR_$(atan2$a3$)",
 111   "neg_optab->handlers[$A].insn_code = CODE_FOR_$(neg$P$a2$)",
 112   "negv_optab->handlers[$A].insn_code =\n\
 113     neg_optab->handlers[$A].insn_code = CODE_FOR_$(neg$F$a2$)",
 114   "negv_optab->handlers[$A].insn_code = CODE_FOR_$(negv$I$a2$)",
 115   "abs_optab->handlers[$A].insn_code = CODE_FOR_$(abs$P$a2$)",
 116   "absv_optab->handlers[$A].insn_code =\n\
 117     abs_optab->handlers[$A].insn_code = CODE_FOR_$(abs$F$a2$)",
 118   "absv_optab->handlers[$A].insn_code = CODE_FOR_$(absv$I$a2$)",
 119   "sqrt_optab->handlers[$A].insn_code = CODE_FOR_$(sqrt$a2$)",
 120   "floor_optab->handlers[$A].insn_code = CODE_FOR_$(floor$a2$)",
 121   "ceil_optab->handlers[$A].insn_code = CODE_FOR_$(ceil$a2$)",
 122   "round_optab->handlers[$A].insn_code = CODE_FOR_$(round$a2$)",
 123   "trunc_optab->handlers[$A].insn_code = CODE_FOR_$(trunc$a2$)",
 124   "nearbyint_optab->handlers[$A].insn_code = CODE_FOR_$(nearbyint$a2$)",
 125   "sin_optab->handlers[$A].insn_code = CODE_FOR_$(sin$a2$)",
 126   "cos_optab->handlers[$A].insn_code = CODE_FOR_$(cos$a2$)",
 127   "exp_optab->handlers[$A].insn_code = CODE_FOR_$(exp$a2$)",
 128   "log_optab->handlers[$A].insn_code = CODE_FOR_$(log$a2$)",
 129   "tan_optab->handlers[$A].insn_code = CODE_FOR_$(tan$a2$)",
 130   "atan_optab->handlers[$A].insn_code = CODE_FOR_$(atan$a2$)",
 131   "strlen_optab->handlers[$A].insn_code = CODE_FOR_$(strlen$a$)",
 132   "one_cmpl_optab->handlers[$A].insn_code = CODE_FOR_$(one_cmpl$a2$)",
 133   "ffs_optab->handlers[$A].insn_code = CODE_FOR_$(ffs$a2$)",
 134   "clz_optab->handlers[$A].insn_code = CODE_FOR_$(clz$a2$)",
 135   "ctz_optab->handlers[$A].insn_code = CODE_FOR_$(ctz$a2$)",
 136   "popcount_optab->handlers[$A].insn_code = CODE_FOR_$(popcount$a2$)",
 137   "parity_optab->handlers[$A].insn_code = CODE_FOR_$(parity$a2$)",
 138   "mov_optab->handlers[$A].insn_code = CODE_FOR_$(mov$a$)",
 139   "movstrict_optab->handlers[$A].insn_code = CODE_FOR_$(movstrict$a$)",
 140   "cmp_optab->handlers[$A].insn_code = CODE_FOR_$(cmp$a$)",
 141   "tst_optab->handlers[$A].insn_code = CODE_FOR_$(tst$a$)",
 142   "addcc_optab->handlers[$A].insn_code = CODE_FOR_$(add$acc$)",
 143   "bcc_gen_fctn[$C] = gen_$(b$c$)",
 144   "setcc_gen_code[$C] = CODE_FOR_$(s$c$)",
 145   "movcc_gen_code[$A] = CODE_FOR_$(mov$acc$)",
 146   "cbranch_optab->handlers[$A].insn_code = CODE_FOR_$(cbranch$a4$)",
 147   "cmov_optab->handlers[$A].insn_code = CODE_FOR_$(cmov$a6$)",
 148   "cstore_optab->handlers[$A].insn_code = CODE_FOR_$(cstore$a4$)",
 149   "push_optab->handlers[$A].insn_code = CODE_FOR_$(push$a1$)",
 150   "reload_in_optab[$A] = CODE_FOR_$(reload_in$a$)",
 151   "reload_out_optab[$A] = CODE_FOR_$(reload_out$a$)",
 152   "movstr_optab[$A] = CODE_FOR_$(movstr$a$)",
 153   "clrstr_optab[$A] = CODE_FOR_$(clrstr$a$)" };
 154
 155 static void gen_insn (rtx);
 156
 157 static void
 158 gen_insn (rtx insn)
 159 {
 160   const char *name = XSTR (insn, 0);
 161   int m1 = 0, m2 = 0, op = 0;
 162   size_t pindex;
 163   int i;
 164   const char *np, *pp, *p, *q;
 165
 166   /* Don't mention instructions whose names are the null string.
 167      They are in the machine description just to be recognized.  */
 168   if (*name == 0)
 169     return;
 170
 171   /* See if NAME matches one of the patterns we have for the optabs we know
 172      about.  */
 173
 174   for (pindex = 0; pindex < ARRAY_SIZE (optabs); pindex++)
 175     {
 176       int force_float = 0, force_int = 0, force_partial_int = 0;
 177       int force_consec = 0;
 178       int matches = 1;
 179
 180       for (pp = optabs[pindex]; pp[0] != '$' || pp[1] != '('; pp++)
 181         ;
 182
 183       for (pp += 2, np = name; matches && ! (pp[0] == '$' && pp[1] == ')');
 184            pp++)
 185         {
 186           if (*pp != '$')
 187             {
 188               if (*pp != *np++)
 189                 break;
 190             }
 191           else
 192             switch (*++pp)
 193               {
 194               case 'N':
 195                 force_consec = 1;
 196                 break;
 197               case 'I':
 198                 force_int = 1;
 199                 break;
 200               case 'P':
 201                 force_partial_int = 1;
 202                 break;
 203               case 'F':
 204                 force_float = 1;
 205                 break;
 206               case 'V':
 207                 break;
 208               case 'c':
 209                 for (op = 0; op < NUM_RTX_CODE; op++)
 210                   {
 211                     for (p = GET_RTX_NAME(op), q = np; *p; p++, q++)
 212                       if (*p != *q)
 213                         break;
 214
 215                     /* We have to be concerned about matching "gt" and
 216                        missing "gtu", e.g., so verify we have reached the
 217                        end of thing we are to match.  */
 218                     if (*p == 0 && *q == 0 && GET_RTX_CLASS(op) == '<')
 219                       break;
 220                   }
 221
 222                 if (op == NUM_RTX_CODE)
 223                   matches = 0;
 224                 else
 225                   np += strlen (GET_RTX_NAME(op));
 226                 break;
 227               case 'a':
 228               case 'b':
 229                 /* This loop will stop at the first prefix match, so
 230                    look through the modes in reverse order, in case
 231                    EXTRA_CC_MODES was used and CC is a prefix of the
 232                    CC modes (as it should be).  */
 233                 for (i = (MAX_MACHINE_MODE) - 1; i >= 0; i--)
 234                   {
 235                     for (p = GET_MODE_NAME(i), q = np; *p; p++, q++)
 236                       if (TOLOWER (*p) != *q)
 237                         break;
 238
 239                     if (*p == 0
 240                         && (! force_int || mode_class[i] == MODE_INT
 241                             || mode_class[i] == MODE_VECTOR_INT)
 242                         && (! force_partial_int
 243                             || mode_class[i] == MODE_INT
 244                             || mode_class[i] == MODE_PARTIAL_INT
 245                             || mode_class[i] == MODE_VECTOR_INT)
 246                         && (! force_float || mode_class[i] == MODE_FLOAT
 247                             || mode_class[i] == MODE_VECTOR_FLOAT))
 248                       break;
 249                   }
 250
 251                 if (i < 0)
 252                   matches = 0;
 253                 else if (*pp == 'a')
 254                   m1 = i, np += strlen (GET_MODE_NAME(i));
 255                 else
 256                   m2 = i, np += strlen (GET_MODE_NAME(i));
 257
 258                 force_int = force_partial_int = force_float = 0;
 259                 break;
 260
 261               default:
 262                 abort ();
 263               }
 264         }
 265
 266       if (matches && pp[0] == '$' && pp[1] == ')'
 267           && *np == 0
 268           && (! force_consec || (int) GET_MODE_WIDER_MODE(m1) == m2))
 269         break;
 270     }
 271
 272   if (pindex == ARRAY_SIZE (optabs))
 273     return;
 274
 275   /* We found a match.  If this pattern is only conditionally present,
 276      write out the "if" and two extra blanks.  */
 277
 278   if (*XSTR (insn, 2) != 0)
 279     printf ("  if (HAVE_%s)\n  ", name);
 280
 281   printf ("  ");
 282
 283   /* Now write out the initialization, making all required substitutions.  */
 284   for (pp = optabs[pindex]; *pp; pp++)
 285     {
 286       if (*pp != '$')
 287         putchar (*pp);
 288       else
 289         switch (*++pp)
 290           {
 291           case '(':  case ')':
 292           case 'I':  case 'F':  case 'N':
 293             break;
 294           case 'V':
 295             if (GET_MODE_CLASS (m1) == MODE_FLOAT)
 296               printf ("v");
 297             break;
 298           case 'a':
 299             for (np = GET_MODE_NAME(m1); *np; np++)
 300               putchar (TOLOWER (*np));
 301             break;
 302           case 'b':
 303             for (np = GET_MODE_NAME(m2); *np; np++)
 304               putchar (TOLOWER (*np));
 305             break;
 306           case 'A':
 307             printf ("%smode", GET_MODE_NAME(m1));
 308             break;
 309           case 'B':
 310             printf ("%smode", GET_MODE_NAME(m2));
 311             break;
 312           case 'c':
 313             printf ("%s", GET_RTX_NAME(op));
 314             break;
 315           case 'C':
 316             for (np = GET_RTX_NAME(op); *np; np++)
 317               putchar (TOUPPER (*np));
 318             break;
 319           }
 320     }
 321
 322   printf (";\n");
 323 }
 324
 325 extern int main (int, char **);
 326
 327 int
 328 main (int argc, char **argv)
 329 {
 330   rtx desc;
 331
 332   progname = "genopinit";
 333
 334   if (argc <= 1)
 335     fatal ("no input file name");
 336
 337   if (init_md_reader_args (argc, argv) != SUCCESS_EXIT_CODE)
 338     return (FATAL_EXIT_CODE);
 339
 340   printf ("/* Generated automatically by the program `genopinit'\n\
 341 from the machine description file `md'.  */\n\n");
 342
 343   printf ("#include \"config.h\"\n");
 344   printf ("#include \"system.h\"\n");
 345   printf ("#include \"coretypes.h\"\n");
 346   printf ("#include \"tm.h\"\n");
 347   printf ("#include \"rtl.h\"\n");
 348   printf ("#include \"flags.h\"\n");
 349   printf ("#include \"insn-config.h\"\n");
 350   printf ("#include \"recog.h\"\n");
 351   printf ("#include \"expr.h\"\n");
 352   printf ("#include \"optabs.h\"\n");
 353   printf ("#include \"reload.h\"\n\n");
 354
 355   printf ("void\ninit_all_optabs (void)\n{\n");
 356
 357   /* Read the machine description.  */
 358
 359   while (1)
 360     {
 361       int line_no, insn_code_number = 0;
 362
 363       desc = read_md_rtx (&line_no, &insn_code_number);
 364       if (desc == NULL)
 365         break;
 366
 367       if (GET_CODE (desc) == DEFINE_INSN || GET_CODE (desc) == DEFINE_EXPAND)
 368         gen_insn (desc);
 369     }
 370
 371   puts ("\
 372 \n\
 373 #ifdef FIXUNS_TRUNC_LIKE_FIX_TRUNC\n\
 374   /* This flag says the same insns that convert to a signed fixnum\n\
 375      also convert validly to an unsigned one.  */\n\
 376   for (i = 0; i < NUM_MACHINE_MODES; i++)\n\
 377     for (j = 0; j < NUM_MACHINE_MODES; j++)\n\
 378       ufixtrunc_optab->handlers[i][j].insn_code\n\
 379       = sfixtrunc_optab->handlers[i][j].insn_code;\n\
 380 #endif\n\
 381 }");
 382
 383   fflush (stdout);
 384   return (ferror (stdout) != 0 ? FATAL_EXIT_CODE : SUCCESS_EXIT_CODE);
 385 }
 386
 387 /* Define this so we can link with print-rtl.o to get debug_rtx function.  */
 388 const char *
 389 get_insn_name (int code ATTRIBUTE_UNUSED)
 390 {
 391   return NULL;
 392 }