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