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