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