gcc/read-md.c

   1 /* MD reader for GCC.
   2    Copyright (C) 1987-2014 Free Software Foundation, Inc.
   3
   4 This file is part of GCC.
   5
   6 GCC is free software; you can redistribute it and/or modify it under
   7 the terms of the GNU General Public License as published by the Free
   8 Software Foundation; either version 3, or (at your option) any later
   9 version.
  10
  11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14 for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GCC; see the file COPYING3.  If not see
  18 <http://www.gnu.org/licenses/>.  */
  19
  20 #include "bconfig.h"
  21 #include "system.h"
  22 #include "coretypes.h"
  23 #include "hashtab.h"
  24 #include "errors.h"
  25 #include "read-md.h"
  26
  27 /* Associates PTR (which can be a string, etc.) with the file location
  28    specified by FILENAME and LINENO.  */
  29 struct ptr_loc {
  30   const void *ptr;
  31   const char *filename;
  32   int lineno;
  33 };
  34
  35 /* A singly-linked list of filenames.  */
  36 struct file_name_list {
  37   struct file_name_list *next;
  38   const char *fname;
  39 };
  40
  41 /* Obstack used for allocating MD strings.  */
  42 struct obstack string_obstack;
  43
  44 /* A table of ptr_locs, hashed on the PTR field.  */
  45 static htab_t ptr_locs;
  46
  47 /* An obstack for the above.  Plain xmalloc is a bit heavyweight for a
  48    small structure like ptr_loc.  */
  49 static struct obstack ptr_loc_obstack;
  50
  51 /* A hash table of triples (A, B, C), where each of A, B and C is a condition
  52    and A is equivalent to "B && C".  This is used to keep track of the source
  53    of conditions that are made up of separate MD strings (such as the split
  54    condition of a define_insn_and_split).  */
  55 static htab_t joined_conditions;
  56
  57 /* An obstack for allocating joined_conditions entries.  */
  58 static struct obstack joined_conditions_obstack;
  59
  60 /* The file we are reading.  */
  61 FILE *read_md_file;
  62
  63 /* The filename of READ_MD_FILE.  */
  64 const char *read_md_filename;
  65
  66 /* The current line number in READ_MD_FILE.  */
  67 int read_md_lineno;
  68
  69 /* The name of the toplevel file that indirectly included READ_MD_FILE.  */
  70 const char *in_fname;
  71
  72 /* The directory part of IN_FNAME.  NULL if IN_FNAME is a bare filename.  */
  73 static char *base_dir;
  74
  75 /* The first directory to search.  */
  76 static struct file_name_list *first_dir_md_include;
  77
  78 /* A pointer to the null terminator of the md include chain.  */
  79 static struct file_name_list **last_dir_md_include_ptr = &first_dir_md_include;
  80
  81 /* This callback will be invoked whenever an md include directive is
  82    processed.  To be used for creation of the dependency file.  */
  83 void (*include_callback) (const char *);
  84
  85 /* The current maximum length of directory names in the search path
  86    for include files.  (Altered as we get more of them.)  */
  87 static size_t max_include_len;
  88
  89 /* A table of md_constant structures, hashed by name.  Null if no
  90    constant expansion should occur.  */
  91 static htab_t md_constants;
  92
  93 /* A table of enum_type structures, hashed by name.  */
  94 static htab_t enum_types;
  95
  96 static void handle_file (directive_handler_t);
  97
  98 /* Given an object that starts with a char * name field, return a hash
  99    code for its name.  */
 100
 101 hashval_t
 102 leading_string_hash (const void *def)
 103 {
 104   return htab_hash_string (*(const char *const *) def);
 105 }
 106
 107 /* Given two objects that start with char * name fields, return true if
 108    they have the same name.  */
 109
 110 int
 111 leading_string_eq_p (const void *def1, const void *def2)
 112 {
 113   return strcmp (*(const char *const *) def1,
 114                  *(const char *const *) def2) == 0;
 115 }
 116
 117 /* Return a hash value for the pointer pointed to by DEF.  */
 118
 119 static hashval_t
 120 leading_ptr_hash (const void *def)
 121 {
 122   return htab_hash_pointer (*(const void *const *) def);
 123 }
 124
 125 /* Return true if DEF1 and DEF2 are pointers to the same pointer.  */
 126
 127 static int
 128 leading_ptr_eq_p (const void *def1, const void *def2)
 129 {
 130   return *(const void *const *) def1 == *(const void *const *) def2;
 131 }
 132
 133 /* Associate PTR with the file position given by FILENAME and LINENO.  */
 134
 135 static void
 136 set_md_ptr_loc (const void *ptr, const char *filename, int lineno)
 137 {
 138   struct ptr_loc *loc;
 139
 140   loc = (struct ptr_loc *) obstack_alloc (&ptr_loc_obstack,
 141                                           sizeof (struct ptr_loc));
 142   loc->ptr = ptr;
 143   loc->filename = filename;
 144   loc->lineno = lineno;
 145   *htab_find_slot (ptr_locs, loc, INSERT) = loc;
 146 }
 147
 148 /* Return the position associated with pointer PTR.  Return null if no
 149    position was set.  */
 150
 151 static const struct ptr_loc *
 152 get_md_ptr_loc (const void *ptr)
 153 {
 154   return (const struct ptr_loc *) htab_find (ptr_locs, &ptr);
 155 }
 156
 157 /* Associate NEW_PTR with the same file position as OLD_PTR.  */
 158
 159 void
 160 copy_md_ptr_loc (const void *new_ptr, const void *old_ptr)
 161 {
 162   const struct ptr_loc *loc = get_md_ptr_loc (old_ptr);
 163   if (loc != 0)
 164     set_md_ptr_loc (new_ptr, loc->filename, loc->lineno);
 165 }
 166
 167 /* If PTR is associated with a known file position, print a #line
 168    directive for it to OUTF.  */
 169
 170 void
 171 fprint_md_ptr_loc (FILE *outf, const void *ptr)
 172 {
 173   const struct ptr_loc *loc = get_md_ptr_loc (ptr);
 174   if (loc != 0)
 175     fprintf (outf, "#line %d \"%s\"\n", loc->lineno, loc->filename);
 176 }
 177
 178 /* Special fprint_md_ptr_loc for writing to STDOUT.  */
 179 void
 180 print_md_ptr_loc (const void *ptr)
 181 {
 182   fprint_md_ptr_loc (stdout, ptr);
 183 }
 184
 185 /* Return a condition that satisfies both COND1 and COND2.  Either string
 186    may be null or empty.  */
 187
 188 const char *
 189 join_c_conditions (const char *cond1, const char *cond2)
 190 {
 191   char *result;
 192   const void **entry;
 193
 194   if (cond1 == 0 || cond1[0] == 0)
 195     return cond2;
 196
 197   if (cond2 == 0 || cond2[0] == 0)
 198     return cond1;
 199
 200   if (strcmp (cond1, cond2) == 0)
 201     return cond1;
 202
 203   result = concat ("(", cond1, ") && (", cond2, ")", NULL);
 204   obstack_ptr_grow (&joined_conditions_obstack, result);
 205   obstack_ptr_grow (&joined_conditions_obstack, cond1);
 206   obstack_ptr_grow (&joined_conditions_obstack, cond2);
 207   entry = XOBFINISH (&joined_conditions_obstack, const void **);
 208   *htab_find_slot (joined_conditions, entry, INSERT) = entry;
 209   return result;
 210 }
 211
 212 /* Print condition COND to OUTF, wrapped in brackets.  If COND was created
 213    by join_c_conditions, recursively invoke this function for the original
 214    conditions and join the result with "&&".  Otherwise print a #line
 215    directive for COND if its original file position is known.  */
 216
 217 void
 218 fprint_c_condition (FILE *outf, const char *cond)
 219 {
 220   const char **halves = (const char **) htab_find (joined_conditions, &cond);
 221   if (halves != 0)
 222     {
 223       fprintf (outf, "(");
 224       fprint_c_condition (outf, halves[1]);
 225       fprintf (outf, " && ");
 226       fprint_c_condition (outf, halves[2]);
 227       fprintf (outf, ")");
 228     }
 229   else
 230     {
 231       fputc ('\n', outf);
 232       fprint_md_ptr_loc (outf, cond);
 233       fprintf (outf, "(%s)", cond);
 234     }
 235 }
 236
 237 /* Special fprint_c_condition for writing to STDOUT.  */
 238
 239 void
 240 print_c_condition (const char *cond)
 241 {
 242   fprint_c_condition (stdout, cond);
 243 }
 244
 245 /* A vfprintf-like function for reporting an error against line LINENO
 246    of the current MD file.  */
 247
 248 static void ATTRIBUTE_PRINTF(2,0)
 249 message_with_line_1 (int lineno, const char *msg, va_list ap)
 250 {
 251   fprintf (stderr, "%s:%d: ", read_md_filename, lineno);
 252   vfprintf (stderr, msg, ap);
 253   fputc ('\n', stderr);
 254 }
 255
 256 /* A printf-like function for reporting an error against line LINENO
 257    in the current MD file.  */
 258
 259 void
 260 message_with_line (int lineno, const char *msg, ...)
 261 {
 262   va_list ap;
 263
 264   va_start (ap, msg);
 265   message_with_line_1 (lineno, msg, ap);
 266   va_end (ap);
 267 }
 268
 269 /* Like message_with_line, but treat the condition as an error.  */
 270
 271 void
 272 error_with_line (int lineno, const char *msg, ...)
 273 {
 274   va_list ap;
 275
 276   va_start (ap, msg);
 277   message_with_line_1 (lineno, msg, ap);
 278   va_end (ap);
 279   have_error = 1;
 280 }
 281
 282 /* A printf-like function for reporting an error against the current
 283    position in the MD file.  */
 284
 285 void
 286 fatal_with_file_and_line (const char *msg, ...)
 287 {
 288   char context[64];
 289   size_t i;
 290   int c;
 291   va_list ap;
 292
 293   va_start (ap, msg);
 294
 295   fprintf (stderr, "%s:%d: ", read_md_filename, read_md_lineno);
 296   vfprintf (stderr, msg, ap);
 297   putc ('\n', stderr);
 298
 299   /* Gather some following context.  */
 300   for (i = 0; i < sizeof (context)-1; ++i)
 301     {
 302       c = read_char ();
 303       if (c == EOF)
 304         break;
 305       if (c == '\r' || c == '\n')
 306         {
 307           unread_char (c);
 308           break;
 309         }
 310       context[i] = c;
 311     }
 312   context[i] = '\0';
 313
 314   fprintf (stderr, "%s:%d: following context is `%s'\n",
 315            read_md_filename, read_md_lineno, context);
 316
 317   va_end (ap);
 318   exit (1);
 319 }
 320
 321 /* Report that we found character ACTUAL when we expected to find
 322    character EXPECTED.  */
 323
 324 void
 325 fatal_expected_char (int expected, int actual)
 326 {
 327   if (actual == EOF)
 328     fatal_with_file_and_line ("expected character `%c', found EOF",
 329                               expected);
 330   else
 331     fatal_with_file_and_line ("expected character `%c', found `%c'",
 332                               expected, actual);
 333 }
 334
 335 /* Read chars from the MD file until a non-whitespace char and return that.
 336    Comments, both Lisp style and C style, are treated as whitespace.  */
 337
 338 int
 339 read_skip_spaces (void)
 340 {
 341   int c;
 342
 343   while (1)
 344     {
 345       c = read_char ();
 346       switch (c)
 347         {
 348         case ' ': case '\t': case '\f': case '\r': case '\n':
 349           break;
 350
 351         case ';':
 352           do
 353             c = read_char ();
 354           while (c != '\n' && c != EOF);
 355           break;
 356
 357         case '/':
 358           {
 359             int prevc;
 360             c = read_char ();
 361             if (c != '*')
 362               {
 363                 unread_char (c);
 364                 fatal_with_file_and_line ("stray '/' in file");
 365               }
 366
 367             prevc = 0;
 368             while ((c = read_char ()) && c != EOF)
 369               {
 370                 if (prevc == '*' && c == '/')
 371                   break;
 372                 prevc = c;
 373               }
 374           }
 375           break;
 376
 377         default:
 378           return c;
 379         }
 380     }
 381 }
 382
 383 /* Read an rtx code name into NAME.  It is terminated by any of the
 384    punctuation chars of rtx printed syntax.  */
 385
 386 void
 387 read_name (struct md_name *name)
 388 {
 389   int c;
 390   size_t i;
 391
 392   c = read_skip_spaces ();
 393
 394   i = 0;
 395   while (1)
 396     {
 397       if (c == ' ' || c == '\n' || c == '\t' || c == '\f' || c == '\r'
 398           || c == EOF)
 399         break;
 400       if (c == ':' || c == ')' || c == ']' || c == '"' || c == '/'
 401           || c == '(' || c == '[')
 402         {
 403           unread_char (c);
 404           break;
 405         }
 406
 407       if (i == sizeof (name->buffer) - 1)
 408         fatal_with_file_and_line ("name too long");
 409       name->buffer[i++] = c;
 410
 411       c = read_char ();
 412     }
 413
 414   if (i == 0)
 415     fatal_with_file_and_line ("missing name or number");
 416
 417   name->buffer[i] = 0;
 418   name->string = name->buffer;
 419
 420   if (md_constants)
 421     {
 422       /* Do constant expansion.  */
 423       struct md_constant *def;
 424
 425       do
 426         {
 427           struct md_constant tmp_def;
 428
 429           tmp_def.name = name->string;
 430           def = (struct md_constant *) htab_find (md_constants, &tmp_def);
 431           if (def)
 432             name->string = def->value;
 433         }
 434       while (def);
 435     }
 436 }
 437
 438 /* Subroutine of the string readers.  Handles backslash escapes.
 439    Caller has read the backslash, but not placed it into the obstack.  */
 440
 441 static void
 442 read_escape (void)
 443 {
 444   int c = read_char ();
 445
 446   switch (c)
 447     {
 448       /* Backslash-newline is replaced by nothing, as in C.  */
 449     case '\n':
 450       return;
 451
 452       /* \" \' \\ are replaced by the second character.  */
 453     case '\\':
 454     case '"':
 455     case '\'':
 456       break;
 457
 458       /* Standard C string escapes:
 459          \a \b \f \n \r \t \v
 460          \[0-7] \x
 461          all are passed through to the output string unmolested.
 462          In normal use these wind up in a string constant processed
 463          by the C compiler, which will translate them appropriately.
 464          We do not bother checking that \[0-7] are followed by up to
 465          two octal digits, or that \x is followed by N hex digits.
 466          \? \u \U are left out because they are not in traditional C.  */
 467     case 'a': case 'b': case 'f': case 'n': case 'r': case 't': case 'v':
 468     case '0': case '1': case '2': case '3': case '4': case '5': case '6':
 469     case '7': case 'x':
 470       obstack_1grow (&string_obstack, '\\');
 471       break;
 472
 473       /* \; makes stuff for a C string constant containing
 474          newline and tab.  */
 475     case ';':
 476       obstack_grow (&string_obstack, "\\n\\t", 4);
 477       return;
 478
 479       /* pass anything else through, but issue a warning.  */
 480     default:
 481       fprintf (stderr, "%s:%d: warning: unrecognized escape \\%c\n",
 482                read_md_filename, read_md_lineno, c);
 483       obstack_1grow (&string_obstack, '\\');
 484       break;
 485     }
 486
 487   obstack_1grow (&string_obstack, c);
 488 }
 489
 490 /* Read a double-quoted string onto the obstack.  Caller has scanned
 491    the leading quote.  */
 492
 493 char *
 494 read_quoted_string (void)
 495 {
 496   int c;
 497
 498   while (1)
 499     {
 500       c = read_char (); /* Read the string  */
 501       if (c == '\\')
 502         {
 503           read_escape ();
 504           continue;
 505         }
 506       else if (c == '"' || c == EOF)
 507         break;
 508
 509       obstack_1grow (&string_obstack, c);
 510     }
 511
 512   obstack_1grow (&string_obstack, 0);
 513   return XOBFINISH (&string_obstack, char *);
 514 }
 515
 516 /* Read a braced string (a la Tcl) onto the string obstack.  Caller
 517    has scanned the leading brace.  Note that unlike quoted strings,
 518    the outermost braces _are_ included in the string constant.  */
 519
 520 static char *
 521 read_braced_string (void)
 522 {
 523   int c;
 524   int brace_depth = 1;  /* caller-processed */
 525   unsigned long starting_read_md_lineno = read_md_lineno;
 526
 527   obstack_1grow (&string_obstack, '{');
 528   while (brace_depth)
 529     {
 530       c = read_char (); /* Read the string  */
 531
 532       if (c == '{')
 533         brace_depth++;
 534       else if (c == '}')
 535         brace_depth--;
 536       else if (c == '\\')
 537         {
 538           read_escape ();
 539           continue;
 540         }
 541       else if (c == EOF)
 542         fatal_with_file_and_line
 543           ("missing closing } for opening brace on line %lu",
 544            starting_read_md_lineno);
 545
 546       obstack_1grow (&string_obstack, c);
 547     }
 548
 549   obstack_1grow (&string_obstack, 0);
 550   return XOBFINISH (&string_obstack, char *);
 551 }
 552
 553 /* Read some kind of string constant.  This is the high-level routine
 554    used by read_rtx.  It handles surrounding parentheses, leading star,
 555    and dispatch to the appropriate string constant reader.  */
 556
 557 char *
 558 read_string (int star_if_braced)
 559 {
 560   char *stringbuf;
 561   int saw_paren = 0;
 562   int c, old_lineno;
 563
 564   c = read_skip_spaces ();
 565   if (c == '(')
 566     {
 567       saw_paren = 1;
 568       c = read_skip_spaces ();
 569     }
 570
 571   old_lineno = read_md_lineno;
 572   if (c == '"')
 573     stringbuf = read_quoted_string ();
 574   else if (c == '{')
 575     {
 576       if (star_if_braced)
 577         obstack_1grow (&string_obstack, '*');
 578       stringbuf = read_braced_string ();
 579     }
 580   else
 581     fatal_with_file_and_line ("expected `\"' or `{', found `%c'", c);
 582
 583   if (saw_paren)
 584     {
 585       c = read_skip_spaces ();
 586       if (c != ')')
 587         fatal_expected_char (')', c);
 588     }
 589
 590   set_md_ptr_loc (stringbuf, read_md_filename, old_lineno);
 591   return stringbuf;
 592 }
 593
 594 /* Skip the rest of a construct that started at line LINENO and that
 595    is currently nested by DEPTH levels of parentheses.  */
 596
 597 void
 598 read_skip_construct (int depth, int lineno)
 599 {
 600   struct md_name name;
 601   int c;
 602
 603   do
 604     {
 605       c = read_skip_spaces ();
 606       if (c == EOF)
 607         {
 608           error_with_line (lineno, "unterminated construct");
 609           exit (1);
 610         }
 611       switch (c)
 612         {
 613         case '(':
 614           depth++;
 615           break;
 616
 617         case ')':
 618           depth--;
 619           break;
 620
 621         case ':':
 622         case '[':
 623         case ']':
 624         case '/':
 625           break;
 626
 627         case '\"':
 628         case '{':
 629           unread_char (c);
 630           read_string (false);
 631           break;
 632
 633         default:
 634           unread_char (c);
 635           read_name (&name);
 636           break;
 637         }
 638     }
 639   while (depth > 0);
 640   unread_char (c);
 641 }
 642
 643 /* Given a string, return the number of comma-separated elements in it.
 644    Return 0 for the null string.  */
 645
 646 int
 647 n_comma_elts (const char *s)
 648 {
 649   int n;
 650
 651   if (*s == '\0')
 652     return 0;
 653
 654   for (n = 1; *s; s++)
 655     if (*s == ',')
 656       n++;
 657
 658   return n;
 659 }
 660
 661 /* Given a pointer to a (char *), return a pointer to the beginning of the
 662    next comma-separated element in the string.  Advance the pointer given
 663    to the end of that element.  Return NULL if at end of string.  Caller
 664    is responsible for copying the string if necessary.  White space between
 665    a comma and an element is ignored.  */
 666
 667 const char *
 668 scan_comma_elt (const char **pstr)
 669 {
 670   const char *start;
 671   const char *p = *pstr;
 672
 673   if (*p == ',')
 674     p++;
 675   while (ISSPACE (*p))
 676     p++;
 677
 678   if (*p == '\0')
 679     return NULL;
 680
 681   start = p;
 682
 683   while (*p != ',' && *p != '\0')
 684     p++;
 685
 686   *pstr = p;
 687   return start;
 688 }
 689
 690 /* Convert STRING to uppercase.  */
 691
 692 void
 693 upcase_string (char *string)
 694 {
 695   int i;
 696
 697   for (i = 0; string[i]; i++)
 698     string[i] = TOUPPER (string[i]);
 699 }
 700
 701 /* Add a NAME = VALUE definition to md_constants-style hash table DEFS,
 702    where both NAME and VALUE are malloc()ed strings.  PARENT_ENUM is the
 703    enum to which NAME belongs, or null if NAME is a stand-alone constant.  */
 704
 705 static struct md_constant *
 706 add_constant (htab_t defs, char *name, char *value,
 707               struct enum_type *parent_enum)
 708 {
 709   struct md_constant *def, tmp_def;
 710   void **entry_ptr;
 711
 712   tmp_def.name = name;
 713   entry_ptr = htab_find_slot (defs, &tmp_def, INSERT);
 714   if (*entry_ptr)
 715     {
 716       def = (struct md_constant *) *entry_ptr;
 717       if (strcmp (def->value, value) != 0)
 718         fatal_with_file_and_line ("redefinition of `%s', was `%s', now `%s'",
 719                                   def->name, def->value, value);
 720       else if (parent_enum || def->parent_enum)
 721         fatal_with_file_and_line ("redefinition of `%s'", def->name);
 722       free (name);
 723       free (value);
 724     }
 725   else
 726     {
 727       def = XNEW (struct md_constant);
 728       def->name = name;
 729       def->value = value;
 730       def->parent_enum = parent_enum;
 731       *entry_ptr = def;
 732     }
 733   return def;
 734 }
 735
 736 /* Process a define_constants directive, starting with the optional space
 737    after the "define_constants".  */
 738
 739 static void
 740 handle_constants (void)
 741 {
 742   int c;
 743   htab_t defs;
 744
 745   c = read_skip_spaces ();
 746   if (c != '[')
 747     fatal_expected_char ('[', c);
 748
 749   /* Disable constant expansion during definition processing.  */
 750   defs = md_constants;
 751   md_constants = 0;
 752   while ( (c = read_skip_spaces ()) != ']')
 753     {
 754       struct md_name name, value;
 755
 756       if (c != '(')
 757         fatal_expected_char ('(', c);
 758
 759       read_name (&name);
 760       read_name (&value);
 761       add_constant (defs, xstrdup (name.string), xstrdup (value.string), 0);
 762
 763       c = read_skip_spaces ();
 764       if (c != ')')
 765         fatal_expected_char (')', c);
 766     }
 767   md_constants = defs;
 768 }
 769
 770 /* For every constant definition, call CALLBACK with two arguments:
 771    a pointer a pointer to the constant definition and INFO.
 772    Stop when CALLBACK returns zero.  */
 773
 774 void
 775 traverse_md_constants (htab_trav callback, void *info)
 776 {
 777   htab_traverse (md_constants, callback, info);
 778 }
 779
 780 /* Return a malloc()ed decimal string that represents number NUMBER.  */
 781
 782 static char *
 783 decimal_string (int number)
 784 {
 785   /* A safe overestimate.  +1 for sign, +1 for null terminator.  */
 786   char buffer[sizeof (int) * CHAR_BIT + 1 + 1];
 787
 788   sprintf (buffer, "%d", number);
 789   return xstrdup (buffer);
 790 }
 791
 792 /* Process a define_enum or define_c_enum directive, starting with
 793    the optional space after the "define_enum".  LINENO is the line
 794    number on which the directive started and MD_P is true if the
 795    directive is a define_enum rather than a define_c_enum.  */
 796
 797 static void
 798 handle_enum (int lineno, bool md_p)
 799 {
 800   char *enum_name, *value_name;
 801   struct md_name name;
 802   struct enum_type *def;
 803   struct enum_value *ev;
 804   void **slot;
 805   int c;
 806
 807   enum_name = read_string (false);
 808   slot = htab_find_slot (enum_types, &enum_name, INSERT);
 809   if (*slot)
 810     {
 811       def = (struct enum_type *) *slot;
 812       if (def->md_p != md_p)
 813         error_with_line (lineno, "redefining `%s' as a different type of enum",
 814                          enum_name);
 815     }
 816   else
 817     {
 818       def = XNEW (struct enum_type);
 819       def->name = enum_name;
 820       def->md_p = md_p;
 821       def->values = 0;
 822       def->tail_ptr = &def->values;
 823       def->num_values = 0;
 824       *slot = def;
 825     }
 826
 827   c = read_skip_spaces ();
 828   if (c != '[')
 829     fatal_expected_char ('[', c);
 830
 831   while ((c = read_skip_spaces ()) != ']')
 832     {
 833       if (c == EOF)
 834         {
 835           error_with_line (lineno, "unterminated construct");
 836           exit (1);
 837         }
 838       unread_char (c);
 839       read_name (&name);
 840
 841       ev = XNEW (struct enum_value);
 842       ev->next = 0;
 843       if (md_p)
 844         {
 845           value_name = concat (def->name, "_", name.string, NULL);
 846           upcase_string (value_name);
 847           ev->name = xstrdup (name.string);
 848         }
 849       else
 850         {
 851           value_name = xstrdup (name.string);
 852           ev->name = value_name;
 853         }
 854       ev->def = add_constant (md_constants, value_name,
 855                               decimal_string (def->num_values), def);
 856
 857       *def->tail_ptr = ev;
 858       def->tail_ptr = &ev->next;
 859       def->num_values++;
 860     }
 861 }
 862
 863 /* Try to find the definition of the given enum.  Return null on failure.  */
 864
 865 struct enum_type *
 866 lookup_enum_type (const char *name)
 867 {
 868   return (struct enum_type *) htab_find (enum_types, &name);
 869 }
 870
 871 /* For every enum definition, call CALLBACK with two arguments:
 872    a pointer to the constant definition and INFO.  Stop when CALLBACK
 873    returns zero.  */
 874
 875 void
 876 traverse_enum_types (htab_trav callback, void *info)
 877 {
 878   htab_traverse (enum_types, callback, info);
 879 }
 880
 881 /* Process an "include" directive, starting with the optional space
 882    after the "include".  Read in the file and use HANDLE_DIRECTIVE
 883    to process each unknown directive.  LINENO is the line number on
 884    which the "include" occurred.  */
 885
 886 static void
 887 handle_include (int lineno, directive_handler_t handle_directive)
 888 {
 889   const char *filename;
 890   const char *old_filename;
 891   int old_lineno;
 892   char *pathname;
 893   FILE *input_file, *old_file;
 894
 895   filename = read_string (false);
 896   input_file = NULL;
 897
 898   /* If the specified file name is absolute, skip the include stack.  */
 899   if (!IS_ABSOLUTE_PATH (filename))
 900     {
 901       struct file_name_list *stackp;
 902
 903       /* Search the directory path, trying to open the file.  */
 904       for (stackp = first_dir_md_include; stackp; stackp = stackp->next)
 905         {
 906           static const char sep[2] = { DIR_SEPARATOR, '\0' };
 907
 908           pathname = concat (stackp->fname, sep, filename, NULL);
 909           input_file = fopen (pathname, "r");
 910           if (input_file != NULL)
 911             break;
 912           free (pathname);
 913         }
 914     }
 915
 916   /* If we haven't managed to open the file yet, try combining the
 917      filename with BASE_DIR.  */
 918   if (input_file == NULL)
 919     {
 920       if (base_dir)
 921         pathname = concat (base_dir, filename, NULL);
 922       else
 923         pathname = xstrdup (filename);
 924       input_file = fopen (pathname, "r");
 925     }
 926
 927   if (input_file == NULL)
 928     {
 929       free (pathname);
 930       error_with_line (lineno, "include file `%s' not found", filename);
 931       return;
 932     }
 933
 934   /* Save the old cursor.  Note that the LINENO argument to this
 935      function is the beginning of the include statement, while
 936      read_md_lineno has already been advanced.  */
 937   old_file = read_md_file;
 938   old_filename = read_md_filename;
 939   old_lineno = read_md_lineno;
 940
 941   if (include_callback)
 942     include_callback (pathname);
 943
 944   read_md_file = input_file;
 945   read_md_filename = pathname;
 946   handle_file (handle_directive);
 947
 948   /* Restore the old cursor.  */
 949   read_md_file = old_file;
 950   read_md_filename = old_filename;
 951   read_md_lineno = old_lineno;
 952
 953   /* Do not free the pathname.  It is attached to the various rtx
 954      queue elements.  */
 955 }
 956
 957 /* Process the current file, assuming that read_md_file and
 958    read_md_filename are valid.  Use HANDLE_DIRECTIVE to handle
 959    unknown directives.  */
 960
 961 static void
 962 handle_file (directive_handler_t handle_directive)
 963 {
 964   struct md_name directive;
 965   int c, lineno;
 966
 967   read_md_lineno = 1;
 968   while ((c = read_skip_spaces ()) != EOF)
 969     {
 970       lineno = read_md_lineno;
 971       if (c != '(')
 972         fatal_expected_char ('(', c);
 973
 974       read_name (&directive);
 975       if (strcmp (directive.string, "define_constants") == 0)
 976         handle_constants ();
 977       else if (strcmp (directive.string, "define_enum") == 0)
 978         handle_enum (lineno, true);
 979       else if (strcmp (directive.string, "define_c_enum") == 0)
 980         handle_enum (lineno, false);
 981       else if (strcmp (directive.string, "include") == 0)
 982         handle_include (lineno, handle_directive);
 983       else if (handle_directive)
 984         handle_directive (lineno, directive.string);
 985       else
 986         read_skip_construct (1, lineno);
 987
 988       c = read_skip_spaces ();
 989       if (c != ')')
 990         fatal_expected_char (')', c);
 991     }
 992   fclose (read_md_file);
 993 }
 994
 995 /* Like handle_file, but for top-level files.  Set up in_fname and
 996    base_dir accordingly.  */
 997
 998 static void
 999 handle_toplevel_file (directive_handler_t handle_directive)
1000 {
1001   const char *base;
1002
1003   in_fname = read_md_filename;
1004   base = lbasename (in_fname);
1005   if (base == in_fname)
1006     base_dir = NULL;
1007   else
1008     base_dir = xstrndup (in_fname, base - in_fname);
1009
1010   handle_file (handle_directive);
1011 }
1012
1013 /* Parse a -I option with argument ARG.  */
1014
1015 static void
1016 parse_include (const char *arg)
1017 {
1018   struct file_name_list *dirtmp;
1019
1020   dirtmp = XNEW (struct file_name_list);
1021   dirtmp->next = 0;
1022   dirtmp->fname = arg;
1023   *last_dir_md_include_ptr = dirtmp;
1024   last_dir_md_include_ptr = &dirtmp->next;
1025   if (strlen (dirtmp->fname) > max_include_len)
1026     max_include_len = strlen (dirtmp->fname);
1027 }
1028
1029 /* The main routine for reading .md files.  Try to process all the .md
1030    files specified on the command line and return true if no error occurred.
1031
1032    ARGC and ARGV are the arguments to main.
1033
1034    PARSE_OPT, if nonnull, is passed all unknown command-line arguments.
1035    It should return true if it recognizes the argument or false if a
1036    generic error should be reported.
1037
1038    If HANDLE_DIRECTIVE is nonnull, the parser calls it for each
1039    unknown directive, otherwise it just skips such directives.
1040    See the comment above the directive_handler_t definition for
1041    details about the callback's interface.  */
1042
1043 bool
1044 read_md_files (int argc, char **argv, bool (*parse_opt) (const char *),
1045                directive_handler_t handle_directive)
1046 {
1047   int i;
1048   bool no_more_options;
1049   bool already_read_stdin;
1050   int num_files;
1051
1052   /* Initialize global data.  */
1053   obstack_init (&string_obstack);
1054   ptr_locs = htab_create (161, leading_ptr_hash, leading_ptr_eq_p, 0);
1055   obstack_init (&ptr_loc_obstack);
1056   joined_conditions = htab_create (161, leading_ptr_hash, leading_ptr_eq_p, 0);
1057   obstack_init (&joined_conditions_obstack);
1058   md_constants = htab_create (31, leading_string_hash,
1059                               leading_string_eq_p, (htab_del) 0);
1060   enum_types = htab_create (31, leading_string_hash,
1061                             leading_string_eq_p, (htab_del) 0);
1062
1063   /* Unlock the stdio streams.  */
1064   unlock_std_streams ();
1065
1066   /* First we loop over all the options.  */
1067   for (i = 1; i < argc; i++)
1068     if (argv[i][0] == '-')
1069       {
1070         /* An argument consisting of exactly one dash is a request to
1071            read stdin.  This will be handled in the second loop.  */
1072         if (argv[i][1] == '\0')
1073           continue;
1074
1075         /* An argument consisting of just two dashes causes option
1076            parsing to cease.  */
1077         if (argv[i][1] == '-' && argv[i][2] == '\0')
1078           break;
1079
1080         if (argv[i][1] == 'I')
1081           {
1082             if (argv[i][2] != '\0')
1083               parse_include (argv[i] + 2);
1084             else if (++i < argc)
1085               parse_include (argv[i]);
1086             else
1087               fatal ("directory name missing after -I option");
1088             continue;
1089           }
1090
1091         /* The program may have provided a callback so it can
1092            accept its own options.  */
1093         if (parse_opt && parse_opt (argv[i]))
1094           continue;
1095
1096         fatal ("invalid option `%s'", argv[i]);
1097       }
1098
1099   /* Now loop over all input files.  */
1100   num_files = 0;
1101   no_more_options = false;
1102   already_read_stdin = false;
1103   for (i = 1; i < argc; i++)
1104     {
1105       if (argv[i][0] == '-')
1106         {
1107           if (argv[i][1] == '\0')
1108             {
1109               /* Read stdin.  */
1110               if (already_read_stdin)
1111                 fatal ("cannot read standard input twice");
1112
1113               read_md_file = stdin;
1114               read_md_filename = "<stdin>";
1115               handle_toplevel_file (handle_directive);
1116               already_read_stdin = true;
1117               continue;
1118             }
1119           else if (argv[i][1] == '-' && argv[i][2] == '\0')
1120             {
1121               /* No further arguments are to be treated as options.  */
1122               no_more_options = true;
1123               continue;
1124             }
1125           else if (!no_more_options)
1126             continue;
1127         }
1128
1129       /* If we get here we are looking at a non-option argument, i.e.
1130          a file to be processed.  */
1131       read_md_filename = argv[i];
1132       read_md_file = fopen (read_md_filename, "r");
1133       if (read_md_file == 0)
1134         {
1135           perror (read_md_filename);
1136           return false;
1137         }
1138       handle_toplevel_file (handle_directive);
1139       num_files++;
1140     }
1141
1142   /* If we get to this point without having seen any files to process,
1143      read the standard input now.  */
1144   if (num_files == 0 && !already_read_stdin)
1145     {
1146       read_md_file = stdin;
1147       read_md_filename = "<stdin>";
1148       handle_toplevel_file (handle_directive);
1149     }
1150
1151   return !have_error;
1152 }