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