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