gold/script.cc

   1 // script.cc -- handle linker scripts for gold.
   2
   3 // Copyright 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
   4 // Written by Ian Lance Taylor <iant@google.com>.
   5
   6 // This file is part of gold.
   7
   8 // This program is free software; you can redistribute it and/or modify
   9 // it under the terms of the GNU General Public License as published by
  10 // the Free Software Foundation; either version 3 of the License, or
  11 // (at your option) any later version.
  12
  13 // This program is distributed in the hope that it will be useful,
  14 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 // GNU General Public License for more details.
  17
  18 // You should have received a copy of the GNU General Public License
  19 // along with this program; if not, write to the Free Software
  20 // Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  21 // MA 02110-1301, USA.
  22
  23 #include "gold.h"
  24
  25 #include <cstdio>
  26 #include <cstdlib>
  27 #include <cstring>
  28 #include <fnmatch.h>
  29 #include <string>
  30 #include <vector>
  31 #include "filenames.h"
  32
  33 #include "elfcpp.h"
  34 #include "demangle.h"
  35 #include "dirsearch.h"
  36 #include "options.h"
  37 #include "fileread.h"
  38 #include "workqueue.h"
  39 #include "readsyms.h"
  40 #include "parameters.h"
  41 #include "layout.h"
  42 #include "symtab.h"
  43 #include "target-select.h"
  44 #include "script.h"
  45 #include "script-c.h"
  46 #include "incremental.h"
  47
  48 namespace gold
  49 {
  50
  51 // A token read from a script file.  We don't implement keywords here;
  52 // all keywords are simply represented as a string.
  53
  54 class Token
  55 {
  56  public:
  57   // Token classification.
  58   enum Classification
  59   {
  60     // Token is invalid.
  61     TOKEN_INVALID,
  62     // Token indicates end of input.
  63     TOKEN_EOF,
  64     // Token is a string of characters.
  65     TOKEN_STRING,
  66     // Token is a quoted string of characters.
  67     TOKEN_QUOTED_STRING,
  68     // Token is an operator.
  69     TOKEN_OPERATOR,
  70     // Token is a number (an integer).
  71     TOKEN_INTEGER
  72   };
  73
  74   // We need an empty constructor so that we can put this STL objects.
  75   Token()
  76     : classification_(TOKEN_INVALID), value_(NULL), value_length_(0),
  77       opcode_(0), lineno_(0), charpos_(0)
  78   { }
  79
  80   // A general token with no value.
  81   Token(Classification classification, int lineno, int charpos)
  82     : classification_(classification), value_(NULL), value_length_(0),
  83       opcode_(0), lineno_(lineno), charpos_(charpos)
  84   {
  85     gold_assert(classification == TOKEN_INVALID
  86                 || classification == TOKEN_EOF);
  87   }
  88
  89   // A general token with a value.
  90   Token(Classification classification, const char* value, size_t length,
  91         int lineno, int charpos)
  92     : classification_(classification), value_(value), value_length_(length),
  93       opcode_(0), lineno_(lineno), charpos_(charpos)
  94   {
  95     gold_assert(classification != TOKEN_INVALID
  96                 && classification != TOKEN_EOF);
  97   }
  98
  99   // A token representing an operator.
 100   Token(int opcode, int lineno, int charpos)
 101     : classification_(TOKEN_OPERATOR), value_(NULL), value_length_(0),
 102       opcode_(opcode), lineno_(lineno), charpos_(charpos)
 103   { }
 104
 105   // Return whether the token is invalid.
 106   bool
 107   is_invalid() const
 108   { return this->classification_ == TOKEN_INVALID; }
 109
 110   // Return whether this is an EOF token.
 111   bool
 112   is_eof() const
 113   { return this->classification_ == TOKEN_EOF; }
 114
 115   // Return the token classification.
 116   Classification
 117   classification() const
 118   { return this->classification_; }
 119
 120   // Return the line number at which the token starts.
 121   int
 122   lineno() const
 123   { return this->lineno_; }
 124
 125   // Return the character position at this the token starts.
 126   int
 127   charpos() const
 128   { return this->charpos_; }
 129
 130   // Get the value of a token.
 131
 132   const char*
 133   string_value(size_t* length) const
 134   {
 135     gold_assert(this->classification_ == TOKEN_STRING
 136                 || this->classification_ == TOKEN_QUOTED_STRING);
 137     *length = this->value_length_;
 138     return this->value_;
 139   }
 140
 141   int
 142   operator_value() const
 143   {
 144     gold_assert(this->classification_ == TOKEN_OPERATOR);
 145     return this->opcode_;
 146   }
 147
 148   uint64_t
 149   integer_value() const
 150   {
 151     gold_assert(this->classification_ == TOKEN_INTEGER);
 152     // Null terminate.
 153     std::string s(this->value_, this->value_length_);
 154     return strtoull(s.c_str(), NULL, 0);
 155   }
 156
 157  private:
 158   // The token classification.
 159   Classification classification_;
 160   // The token value, for TOKEN_STRING or TOKEN_QUOTED_STRING or
 161   // TOKEN_INTEGER.
 162   const char* value_;
 163   // The length of the token value.
 164   size_t value_length_;
 165   // The token value, for TOKEN_OPERATOR.
 166   int opcode_;
 167   // The line number where this token started (one based).
 168   int lineno_;
 169   // The character position within the line where this token started
 170   // (one based).
 171   int charpos_;
 172 };
 173
 174 // This class handles lexing a file into a sequence of tokens.
 175
 176 class Lex
 177 {
 178  public:
 179   // We unfortunately have to support different lexing modes, because
 180   // when reading different parts of a linker script we need to parse
 181   // things differently.
 182   enum Mode
 183   {
 184     // Reading an ordinary linker script.
 185     LINKER_SCRIPT,
 186     // Reading an expression in a linker script.
 187     EXPRESSION,
 188     // Reading a version script.
 189     VERSION_SCRIPT,
 190     // Reading a --dynamic-list file.
 191     DYNAMIC_LIST
 192   };
 193
 194   Lex(const char* input_string, size_t input_length, int parsing_token)
 195     : input_string_(input_string), input_length_(input_length),
 196       current_(input_string), mode_(LINKER_SCRIPT),
 197       first_token_(parsing_token), token_(),
 198       lineno_(1), linestart_(input_string)
 199   { }
 200
 201   // Read a file into a string.
 202   static void
 203   read_file(Input_file*, std::string*);
 204
 205   // Return the next token.
 206   const Token*
 207   next_token();
 208
 209   // Return the current lexing mode.
 210   Lex::Mode
 211   mode() const
 212   { return this->mode_; }
 213
 214   // Set the lexing mode.
 215   void
 216   set_mode(Mode mode)
 217   { this->mode_ = mode; }
 218
 219  private:
 220   Lex(const Lex&);
 221   Lex& operator=(const Lex&);
 222
 223   // Make a general token with no value at the current location.
 224   Token
 225   make_token(Token::Classification c, const char* start) const
 226   { return Token(c, this->lineno_, start - this->linestart_ + 1); }
 227
 228   // Make a general token with a value at the current location.
 229   Token
 230   make_token(Token::Classification c, const char* v, size_t len,
 231              const char* start)
 232     const
 233   { return Token(c, v, len, this->lineno_, start - this->linestart_ + 1); }
 234
 235   // Make an operator token at the current location.
 236   Token
 237   make_token(int opcode, const char* start) const
 238   { return Token(opcode, this->lineno_, start - this->linestart_ + 1); }
 239
 240   // Make an invalid token at the current location.
 241   Token
 242   make_invalid_token(const char* start)
 243   { return this->make_token(Token::TOKEN_INVALID, start); }
 244
 245   // Make an EOF token at the current location.
 246   Token
 247   make_eof_token(const char* start)
 248   { return this->make_token(Token::TOKEN_EOF, start); }
 249
 250   // Return whether C can be the first character in a name.  C2 is the
 251   // next character, since we sometimes need that.
 252   inline bool
 253   can_start_name(char c, char c2);
 254
 255   // If C can appear in a name which has already started, return a
 256   // pointer to a character later in the token or just past
 257   // it. Otherwise, return NULL.
 258   inline const char*
 259   can_continue_name(const char* c);
 260
 261   // Return whether C, C2, C3 can start a hex number.
 262   inline bool
 263   can_start_hex(char c, char c2, char c3);
 264
 265   // If C can appear in a hex number which has already started, return
 266   // a pointer to a character later in the token or just past
 267   // it. Otherwise, return NULL.
 268   inline const char*
 269   can_continue_hex(const char* c);
 270
 271   // Return whether C can start a non-hex number.
 272   static inline bool
 273   can_start_number(char c);
 274
 275   // If C can appear in a decimal number which has already started,
 276   // return a pointer to a character later in the token or just past
 277   // it. Otherwise, return NULL.
 278   inline const char*
 279   can_continue_number(const char* c)
 280   { return Lex::can_start_number(*c) ? c + 1 : NULL; }
 281
 282   // If C1 C2 C3 form a valid three character operator, return the
 283   // opcode.  Otherwise return 0.
 284   static inline int
 285   three_char_operator(char c1, char c2, char c3);
 286
 287   // If C1 C2 form a valid two character operator, return the opcode.
 288   // Otherwise return 0.
 289   static inline int
 290   two_char_operator(char c1, char c2);
 291
 292   // If C1 is a valid one character operator, return the opcode.
 293   // Otherwise return 0.
 294   static inline int
 295   one_char_operator(char c1);
 296
 297   // Read the next token.
 298   Token
 299   get_token(const char**);
 300
 301   // Skip a C style /* */ comment.  Return false if the comment did
 302   // not end.
 303   bool
 304   skip_c_comment(const char**);
 305
 306   // Skip a line # comment.  Return false if there was no newline.
 307   bool
 308   skip_line_comment(const char**);
 309
 310   // Build a token CLASSIFICATION from all characters that match
 311   // CAN_CONTINUE_FN.  The token starts at START.  Start matching from
 312   // MATCH.  Set *PP to the character following the token.
 313   inline Token
 314   gather_token(Token::Classification,
 315                const char* (Lex::*can_continue_fn)(const char*),
 316                const char* start, const char* match, const char** pp);
 317
 318   // Build a token from a quoted string.
 319   Token
 320   gather_quoted_string(const char** pp);
 321
 322   // The string we are tokenizing.
 323   const char* input_string_;
 324   // The length of the string.
 325   size_t input_length_;
 326   // The current offset into the string.
 327   const char* current_;
 328   // The current lexing mode.
 329   Mode mode_;
 330   // The code to use for the first token.  This is set to 0 after it
 331   // is used.
 332   int first_token_;
 333   // The current token.
 334   Token token_;
 335   // The current line number.
 336   int lineno_;
 337   // The start of the current line in the string.
 338   const char* linestart_;
 339 };
 340
 341 // Read the whole file into memory.  We don't expect linker scripts to
 342 // be large, so we just use a std::string as a buffer.  We ignore the
 343 // data we've already read, so that we read aligned buffers.
 344
 345 void
 346 Lex::read_file(Input_file* input_file, std::string* contents)
 347 {
 348   off_t filesize = input_file->file().filesize();
 349   contents->clear();
 350   contents->reserve(filesize);
 351
 352   off_t off = 0;
 353   unsigned char buf[BUFSIZ];
 354   while (off < filesize)
 355     {
 356       off_t get = BUFSIZ;
 357       if (get > filesize - off)
 358         get = filesize - off;
 359       input_file->file().read(off, get, buf);
 360       contents->append(reinterpret_cast<char*>(&buf[0]), get);
 361       off += get;
 362     }
 363 }
 364
 365 // Return whether C can be the start of a name, if the next character
 366 // is C2.  A name can being with a letter, underscore, period, or
 367 // dollar sign.  Because a name can be a file name, we also permit
 368 // forward slash, backslash, and tilde.  Tilde is the tricky case
 369 // here; GNU ld also uses it as a bitwise not operator.  It is only
 370 // recognized as the operator if it is not immediately followed by
 371 // some character which can appear in a symbol.  That is, when we
 372 // don't know that we are looking at an expression, "~0" is a file
 373 // name, and "~ 0" is an expression using bitwise not.  We are
 374 // compatible.
 375
 376 inline bool
 377 Lex::can_start_name(char c, char c2)
 378 {
 379   switch (c)
 380     {
 381     case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
 382     case 'G': case 'H': case 'I': case 'J': case 'K': case 'L':
 383     case 'M': case 'N': case 'O': case 'Q': case 'P': case 'R':
 384     case 'S': case 'T': case 'U': case 'V': case 'W': case 'X':
 385     case 'Y': case 'Z':
 386     case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
 387     case 'g': case 'h': case 'i': case 'j': case 'k': case 'l':
 388     case 'm': case 'n': case 'o': case 'q': case 'p': case 'r':
 389     case 's': case 't': case 'u': case 'v': case 'w': case 'x':
 390     case 'y': case 'z':
 391     case '_': case '.': case '$':
 392       return true;
 393
 394     case '/': case '\\':
 395       return this->mode_ == LINKER_SCRIPT;
 396
 397     case '~':
 398       return this->mode_ == LINKER_SCRIPT && can_continue_name(&c2);
 399
 400     case '*': case '[':
 401       return (this->mode_ == VERSION_SCRIPT
 402               || this->mode_ == DYNAMIC_LIST
 403               || (this->mode_ == LINKER_SCRIPT
 404                   && can_continue_name(&c2)));
 405
 406     default:
 407       return false;
 408     }
 409 }
 410
 411 // Return whether C can continue a name which has already started.
 412 // Subsequent characters in a name are the same as the leading
 413 // characters, plus digits and "=+-:[],?*".  So in general the linker
 414 // script language requires spaces around operators, unless we know
 415 // that we are parsing an expression.
 416
 417 inline const char*
 418 Lex::can_continue_name(const char* c)
 419 {
 420   switch (*c)
 421     {
 422     case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
 423     case 'G': case 'H': case 'I': case 'J': case 'K': case 'L':
 424     case 'M': case 'N': case 'O': case 'Q': case 'P': case 'R':
 425     case 'S': case 'T': case 'U': case 'V': case 'W': case 'X':
 426     case 'Y': case 'Z':
 427     case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
 428     case 'g': case 'h': case 'i': case 'j': case 'k': case 'l':
 429     case 'm': case 'n': case 'o': case 'q': case 'p': case 'r':
 430     case 's': case 't': case 'u': case 'v': case 'w': case 'x':
 431     case 'y': case 'z':
 432     case '_': case '.': case '$':
 433     case '0': case '1': case '2': case '3': case '4':
 434     case '5': case '6': case '7': case '8': case '9':
 435       return c + 1;
 436
 437     // TODO(csilvers): why not allow ~ in names for version-scripts?
 438     case '/': case '\\': case '~':
 439     case '=': case '+':
 440     case ',':
 441       if (this->mode_ == LINKER_SCRIPT)
 442         return c + 1;
 443       return NULL;
 444
 445     case '[': case ']': case '*': case '?': case '-':
 446       if (this->mode_ == LINKER_SCRIPT || this->mode_ == VERSION_SCRIPT
 447           || this->mode_ == DYNAMIC_LIST)
 448         return c + 1;
 449       return NULL;
 450
 451     // TODO(csilvers): why allow this?  ^ is meaningless in version scripts.
 452     case '^':
 453       if (this->mode_ == VERSION_SCRIPT || this->mode_ == DYNAMIC_LIST)
 454         return c + 1;
 455       return NULL;
 456
 457     case ':':
 458       if (this->mode_ == LINKER_SCRIPT)
 459         return c + 1;
 460       else if ((this->mode_ == VERSION_SCRIPT || this->mode_ == DYNAMIC_LIST)
 461                && (c[1] == ':'))
 462         {
 463           // A name can have '::' in it, as that's a c++ namespace
 464           // separator. But a single colon is not part of a name.
 465           return c + 2;
 466         }
 467       return NULL;
 468
 469     default:
 470       return NULL;
 471     }
 472 }
 473
 474 // For a number we accept 0x followed by hex digits, or any sequence
 475 // of digits.  The old linker accepts leading '$' for hex, and
 476 // trailing HXBOD.  Those are for MRI compatibility and we don't
 477 // accept them.  The old linker also accepts trailing MK for mega or
 478 // kilo.  FIXME: Those are mentioned in the documentation, and we
 479 // should accept them.
 480
 481 // Return whether C1 C2 C3 can start a hex number.
 482
 483 inline bool
 484 Lex::can_start_hex(char c1, char c2, char c3)
 485 {
 486   if (c1 == '0' && (c2 == 'x' || c2 == 'X'))
 487     return this->can_continue_hex(&c3);
 488   return false;
 489 }
 490
 491 // Return whether C can appear in a hex number.
 492
 493 inline const char*
 494 Lex::can_continue_hex(const char* c)
 495 {
 496   switch (*c)
 497     {
 498     case '0': case '1': case '2': case '3': case '4':
 499     case '5': case '6': case '7': case '8': case '9':
 500     case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
 501     case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
 502       return c + 1;
 503
 504     default:
 505       return NULL;
 506     }
 507 }
 508
 509 // Return whether C can start a non-hex number.
 510
 511 inline bool
 512 Lex::can_start_number(char c)
 513 {
 514   switch (c)
 515     {
 516     case '0': case '1': case '2': case '3': case '4':
 517     case '5': case '6': case '7': case '8': case '9':
 518       return true;
 519
 520     default:
 521       return false;
 522     }
 523 }
 524
 525 // If C1 C2 C3 form a valid three character operator, return the
 526 // opcode (defined in the yyscript.h file generated from yyscript.y).
 527 // Otherwise return 0.
 528
 529 inline int
 530 Lex::three_char_operator(char c1, char c2, char c3)
 531 {
 532   switch (c1)
 533     {
 534     case '<':
 535       if (c2 == '<' && c3 == '=')
 536         return LSHIFTEQ;
 537       break;
 538     case '>':
 539       if (c2 == '>' && c3 == '=')
 540         return RSHIFTEQ;
 541       break;
 542     default:
 543       break;
 544     }
 545   return 0;
 546 }
 547
 548 // If C1 C2 form a valid two character operator, return the opcode
 549 // (defined in the yyscript.h file generated from yyscript.y).
 550 // Otherwise return 0.
 551
 552 inline int
 553 Lex::two_char_operator(char c1, char c2)
 554 {
 555   switch (c1)
 556     {
 557     case '=':
 558       if (c2 == '=')
 559         return EQ;
 560       break;
 561     case '!':
 562       if (c2 == '=')
 563         return NE;
 564       break;
 565     case '+':
 566       if (c2 == '=')
 567         return PLUSEQ;
 568       break;
 569     case '-':
 570       if (c2 == '=')
 571         return MINUSEQ;
 572       break;
 573     case '*':
 574       if (c2 == '=')
 575         return MULTEQ;
 576       break;
 577     case '/':
 578       if (c2 == '=')
 579         return DIVEQ;
 580       break;
 581     case '|':
 582       if (c2 == '=')
 583         return OREQ;
 584       if (c2 == '|')
 585         return OROR;
 586       break;
 587     case '&':
 588       if (c2 == '=')
 589         return ANDEQ;
 590       if (c2 == '&')
 591         return ANDAND;
 592       break;
 593     case '>':
 594       if (c2 == '=')
 595         return GE;
 596       if (c2 == '>')
 597         return RSHIFT;
 598       break;
 599     case '<':
 600       if (c2 == '=')
 601         return LE;
 602       if (c2 == '<')
 603         return LSHIFT;
 604       break;
 605     default:
 606       break;
 607     }
 608   return 0;
 609 }
 610
 611 // If C1 is a valid operator, return the opcode.  Otherwise return 0.
 612
 613 inline int
 614 Lex::one_char_operator(char c1)
 615 {
 616   switch (c1)
 617     {
 618     case '+':
 619     case '-':
 620     case '*':
 621     case '/':
 622     case '%':
 623     case '!':
 624     case '&':
 625     case '|':
 626     case '^':
 627     case '~':
 628     case '<':
 629     case '>':
 630     case '=':
 631     case '?':
 632     case ',':
 633     case '(':
 634     case ')':
 635     case '{':
 636     case '}':
 637     case '[':
 638     case ']':
 639     case ':':
 640     case ';':
 641       return c1;
 642     default:
 643       return 0;
 644     }
 645 }
 646
 647 // Skip a C style comment.  *PP points to just after the "/*".  Return
 648 // false if the comment did not end.
 649
 650 bool
 651 Lex::skip_c_comment(const char** pp)
 652 {
 653   const char* p = *pp;
 654   while (p[0] != '*' || p[1] != '/')
 655     {
 656       if (*p == '\0')
 657         {
 658           *pp = p;
 659           return false;
 660         }
 661
 662       if (*p == '\n')
 663         {
 664           ++this->lineno_;
 665           this->linestart_ = p + 1;
 666         }
 667       ++p;
 668     }
 669
 670   *pp = p + 2;
 671   return true;
 672 }
 673
 674 // Skip a line # comment.  Return false if there was no newline.
 675
 676 bool
 677 Lex::skip_line_comment(const char** pp)
 678 {
 679   const char* p = *pp;
 680   size_t skip = strcspn(p, "\n");
 681   if (p[skip] == '\0')
 682     {
 683       *pp = p + skip;
 684       return false;
 685     }
 686
 687   p += skip + 1;
 688   ++this->lineno_;
 689   this->linestart_ = p;
 690   *pp = p;
 691
 692   return true;
 693 }
 694
 695 // Build a token CLASSIFICATION from all characters that match
 696 // CAN_CONTINUE_FN.  Update *PP.
 697
 698 inline Token
 699 Lex::gather_token(Token::Classification classification,
 700                   const char* (Lex::*can_continue_fn)(const char*),
 701                   const char* start,
 702                   const char* match,
 703                   const char** pp)
 704 {
 705   const char* new_match = NULL;
 706   while ((new_match = (this->*can_continue_fn)(match)))
 707     match = new_match;
 708   *pp = match;
 709   return this->make_token(classification, start, match - start, start);
 710 }
 711
 712 // Build a token from a quoted string.
 713
 714 Token
 715 Lex::gather_quoted_string(const char** pp)
 716 {
 717   const char* start = *pp;
 718   const char* p = start;
 719   ++p;
 720   size_t skip = strcspn(p, "\"\n");
 721   if (p[skip] != '"')
 722     return this->make_invalid_token(start);
 723   *pp = p + skip + 1;
 724   return this->make_token(Token::TOKEN_QUOTED_STRING, p, skip, start);
 725 }
 726
 727 // Return the next token at *PP.  Update *PP.  General guideline: we
 728 // require linker scripts to be simple ASCII.  No unicode linker
 729 // scripts.  In particular we can assume that any '\0' is the end of
 730 // the input.
 731
 732 Token
 733 Lex::get_token(const char** pp)
 734 {
 735   const char* p = *pp;
 736
 737   while (true)
 738     {
 739       if (*p == '\0')
 740         {
 741           *pp = p;
 742           return this->make_eof_token(p);
 743         }
 744
 745       // Skip whitespace quickly.
 746       while (*p == ' ' || *p == '\t' || *p == '\r')
 747         ++p;
 748
 749       if (*p == '\n')
 750         {
 751           ++p;
 752           ++this->lineno_;
 753           this->linestart_ = p;
 754           continue;
 755         }
 756
 757       // Skip C style comments.
 758       if (p[0] == '/' && p[1] == '*')
 759         {
 760           int lineno = this->lineno_;
 761           int charpos = p - this->linestart_ + 1;
 762
 763           *pp = p + 2;
 764           if (!this->skip_c_comment(pp))
 765             return Token(Token::TOKEN_INVALID, lineno, charpos);
 766           p = *pp;
 767
 768           continue;
 769         }
 770
 771       // Skip line comments.
 772       if (*p == '#')
 773         {
 774           *pp = p + 1;
 775           if (!this->skip_line_comment(pp))
 776             return this->make_eof_token(p);
 777           p = *pp;
 778           continue;
 779         }
 780
 781       // Check for a name.
 782       if (this->can_start_name(p[0], p[1]))
 783         return this->gather_token(Token::TOKEN_STRING,
 784                                   &Lex::can_continue_name,
 785                                   p, p + 1, pp);
 786
 787       // We accept any arbitrary name in double quotes, as long as it
 788       // does not cross a line boundary.
 789       if (*p == '"')
 790         {
 791           *pp = p;
 792           return this->gather_quoted_string(pp);
 793         }
 794
 795       // Check for a number.
 796
 797       if (this->can_start_hex(p[0], p[1], p[2]))
 798         return this->gather_token(Token::TOKEN_INTEGER,
 799                                   &Lex::can_continue_hex,
 800                                   p, p + 3, pp);
 801
 802       if (Lex::can_start_number(p[0]))
 803         return this->gather_token(Token::TOKEN_INTEGER,
 804                                   &Lex::can_continue_number,
 805                                   p, p + 1, pp);
 806
 807       // Check for operators.
 808
 809       int opcode = Lex::three_char_operator(p[0], p[1], p[2]);
 810       if (opcode != 0)
 811         {
 812           *pp = p + 3;
 813           return this->make_token(opcode, p);
 814         }
 815
 816       opcode = Lex::two_char_operator(p[0], p[1]);
 817       if (opcode != 0)
 818         {
 819           *pp = p + 2;
 820           return this->make_token(opcode, p);
 821         }
 822
 823       opcode = Lex::one_char_operator(p[0]);
 824       if (opcode != 0)
 825         {
 826           *pp = p + 1;
 827           return this->make_token(opcode, p);
 828         }
 829
 830       return this->make_token(Token::TOKEN_INVALID, p);
 831     }
 832 }
 833
 834 // Return the next token.
 835
 836 const Token*
 837 Lex::next_token()
 838 {
 839   // The first token is special.
 840   if (this->first_token_ != 0)
 841     {
 842       this->token_ = Token(this->first_token_, 0, 0);
 843       this->first_token_ = 0;
 844       return &this->token_;
 845     }
 846
 847   this->token_ = this->get_token(&this->current_);
 848
 849   // Don't let an early null byte fool us into thinking that we've
 850   // reached the end of the file.
 851   if (this->token_.is_eof()
 852       && (static_cast<size_t>(this->current_ - this->input_string_)
 853           < this->input_length_))
 854     this->token_ = this->make_invalid_token(this->current_);
 855
 856   return &this->token_;
 857 }
 858
 859 // class Symbol_assignment.
 860
 861 // Add the symbol to the symbol table.  This makes sure the symbol is
 862 // there and defined.  The actual value is stored later.  We can't
 863 // determine the actual value at this point, because we can't
 864 // necessarily evaluate the expression until all ordinary symbols have
 865 // been finalized.
 866
 867 // The GNU linker lets symbol assignments in the linker script
 868 // silently override defined symbols in object files.  We are
 869 // compatible.  FIXME: Should we issue a warning?
 870
 871 void
 872 Symbol_assignment::add_to_table(Symbol_table* symtab)
 873 {
 874   elfcpp::STV vis = this->hidden_ ? elfcpp::STV_HIDDEN : elfcpp::STV_DEFAULT;
 875   this->sym_ = symtab->define_as_constant(this->name_.c_str(),
 876                                           NULL, // version
 877                                           (this->is_defsym_
 878                                            ? Symbol_table::DEFSYM
 879                                            : Symbol_table::SCRIPT),
 880                                           0, // value
 881                                           0, // size
 882                                           elfcpp::STT_NOTYPE,
 883                                           elfcpp::STB_GLOBAL,
 884                                           vis,
 885                                           0, // nonvis
 886                                           this->provide_,
 887                                           true); // force_override
 888 }
 889
 890 // Finalize a symbol value.
 891
 892 void
 893 Symbol_assignment::finalize(Symbol_table* symtab, const Layout* layout)
 894 {
 895   this->finalize_maybe_dot(symtab, layout, false, 0, NULL);
 896 }
 897
 898 // Finalize a symbol value which can refer to the dot symbol.
 899
 900 void
 901 Symbol_assignment::finalize_with_dot(Symbol_table* symtab,
 902                                      const Layout* layout,
 903                                      uint64_t dot_value,
 904                                      Output_section* dot_section)
 905 {
 906   this->finalize_maybe_dot(symtab, layout, true, dot_value, dot_section);
 907 }
 908
 909 // Finalize a symbol value, internal version.
 910
 911 void
 912 Symbol_assignment::finalize_maybe_dot(Symbol_table* symtab,
 913                                       const Layout* layout,
 914                                       bool is_dot_available,
 915                                       uint64_t dot_value,
 916                                       Output_section* dot_section)
 917 {
 918   // If we were only supposed to provide this symbol, the sym_ field
 919   // will be NULL if the symbol was not referenced.
 920   if (this->sym_ == NULL)
 921     {
 922       gold_assert(this->provide_);
 923       return;
 924     }
 925
 926   if (parameters->target().get_size() == 32)
 927     {
 928 #if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_32_BIG)
 929       this->sized_finalize<32>(symtab, layout, is_dot_available, dot_value,
 930                                dot_section);
 931 #else
 932       gold_unreachable();
 933 #endif
 934     }
 935   else if (parameters->target().get_size() == 64)
 936     {
 937 #if defined(HAVE_TARGET_64_LITTLE) || defined(HAVE_TARGET_64_BIG)
 938       this->sized_finalize<64>(symtab, layout, is_dot_available, dot_value,
 939                                dot_section);
 940 #else
 941       gold_unreachable();
 942 #endif
 943     }
 944   else
 945     gold_unreachable();
 946 }
 947
 948 template<int size>
 949 void
 950 Symbol_assignment::sized_finalize(Symbol_table* symtab, const Layout* layout,
 951                                   bool is_dot_available, uint64_t dot_value,
 952                                   Output_section* dot_section)
 953 {
 954   Output_section* section;
 955   uint64_t final_val = this->val_->eval_maybe_dot(symtab, layout, true,
 956                                                   is_dot_available,
 957                                                   dot_value, dot_section,
 958                                                   &section, NULL);
 959   Sized_symbol<size>* ssym = symtab->get_sized_symbol<size>(this->sym_);
 960   ssym->set_value(final_val);
 961   if (section != NULL)
 962     ssym->set_output_section(section);
 963 }
 964
 965 // Set the symbol value if the expression yields an absolute value.
 966
 967 void
 968 Symbol_assignment::set_if_absolute(Symbol_table* symtab, const Layout* layout,
 969                                    bool is_dot_available, uint64_t dot_value)
 970 {
 971   if (this->sym_ == NULL)
 972     return;
 973
 974   Output_section* val_section;
 975   uint64_t val = this->val_->eval_maybe_dot(symtab, layout, false,
 976                                             is_dot_available, dot_value,
 977                                             NULL, &val_section, NULL);
 978   if (val_section != NULL)
 979     return;
 980
 981   if (parameters->target().get_size() == 32)
 982     {
 983 #if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_32_BIG)
 984       Sized_symbol<32>* ssym = symtab->get_sized_symbol<32>(this->sym_);
 985       ssym->set_value(val);
 986 #else
 987       gold_unreachable();
 988 #endif
 989     }
 990   else if (parameters->target().get_size() == 64)
 991     {
 992 #if defined(HAVE_TARGET_64_LITTLE) || defined(HAVE_TARGET_64_BIG)
 993       Sized_symbol<64>* ssym = symtab->get_sized_symbol<64>(this->sym_);
 994       ssym->set_value(val);
 995 #else
 996       gold_unreachable();
 997 #endif
 998     }
 999   else
1000     gold_unreachable();
1001 }
1002
1003 // Print for debugging.
1004
1005 void
1006 Symbol_assignment::print(FILE* f) const
1007 {
1008   if (this->provide_ && this->hidden_)
1009     fprintf(f, "PROVIDE_HIDDEN(");
1010   else if (this->provide_)
1011     fprintf(f, "PROVIDE(");
1012   else if (this->hidden_)
1013     gold_unreachable();
1014
1015   fprintf(f, "%s = ", this->name_.c_str());
1016   this->val_->print(f);
1017
1018   if (this->provide_ || this->hidden_)
1019     fprintf(f, ")");
1020
1021   fprintf(f, "\n");
1022 }
1023
1024 // Class Script_assertion.
1025
1026 // Check the assertion.
1027
1028 void
1029 Script_assertion::check(const Symbol_table* symtab, const Layout* layout)
1030 {
1031   if (!this->check_->eval(symtab, layout, true))
1032     gold_error("%s", this->message_.c_str());
1033 }
1034
1035 // Print for debugging.
1036
1037 void
1038 Script_assertion::print(FILE* f) const
1039 {
1040   fprintf(f, "ASSERT(");
1041   this->check_->print(f);
1042   fprintf(f, ", \"%s\")\n", this->message_.c_str());
1043 }
1044
1045 // Class Script_options.
1046
1047 Script_options::Script_options()
1048   : entry_(), symbol_assignments_(), symbol_definitions_(),
1049     symbol_references_(), version_script_info_(), script_sections_()
1050 {
1051 }
1052
1053 // Add a symbol to be defined.
1054
1055 void
1056 Script_options::add_symbol_assignment(const char* name, size_t length,
1057                                       bool is_defsym, Expression* value,
1058                                       bool provide, bool hidden)
1059 {
1060   if (length != 1 || name[0] != '.')
1061     {
1062       if (this->script_sections_.in_sections_clause())
1063         {
1064           gold_assert(!is_defsym);
1065           this->script_sections_.add_symbol_assignment(name, length, value,
1066                                                        provide, hidden);
1067         }
1068       else
1069         {
1070           Symbol_assignment* p = new Symbol_assignment(name, length, is_defsym,
1071                                                        value, provide, hidden);
1072           this->symbol_assignments_.push_back(p);
1073         }
1074
1075       if (!provide)
1076         {
1077           std::string n(name, length);
1078           this->symbol_definitions_.insert(n);
1079           this->symbol_references_.erase(n);
1080         }
1081     }
1082   else
1083     {
1084       if (provide || hidden)
1085         gold_error(_("invalid use of PROVIDE for dot symbol"));
1086
1087       // The GNU linker permits assignments to dot outside of SECTIONS
1088       // clauses and treats them as occurring inside, so we don't
1089       // check in_sections_clause here.
1090       this->script_sections_.add_dot_assignment(value);
1091     }
1092 }
1093
1094 // Add a reference to a symbol.
1095
1096 void
1097 Script_options::add_symbol_reference(const char* name, size_t length)
1098 {
1099   if (length != 1 || name[0] != '.')
1100     {
1101       std::string n(name, length);
1102       if (this->symbol_definitions_.find(n) == this->symbol_definitions_.end())
1103         this->symbol_references_.insert(n);
1104     }
1105 }
1106
1107 // Add an assertion.
1108
1109 void
1110 Script_options::add_assertion(Expression* check, const char* message,
1111                               size_t messagelen)
1112 {
1113   if (this->script_sections_.in_sections_clause())
1114     this->script_sections_.add_assertion(check, message, messagelen);
1115   else
1116     {
1117       Script_assertion* p = new Script_assertion(check, message, messagelen);
1118       this->assertions_.push_back(p);
1119     }
1120 }
1121
1122 // Create sections required by any linker scripts.
1123
1124 void
1125 Script_options::create_script_sections(Layout* layout)
1126 {
1127   if (this->saw_sections_clause())
1128     this->script_sections_.create_sections(layout);
1129 }
1130
1131 // Add any symbols we are defining to the symbol table.
1132
1133 void
1134 Script_options::add_symbols_to_table(Symbol_table* symtab)
1135 {
1136   for (Symbol_assignments::iterator p = this->symbol_assignments_.begin();
1137        p != this->symbol_assignments_.end();
1138        ++p)
1139     (*p)->add_to_table(symtab);
1140   this->script_sections_.add_symbols_to_table(symtab);
1141 }
1142
1143 // Finalize symbol values.  Also check assertions.
1144
1145 void
1146 Script_options::finalize_symbols(Symbol_table* symtab, const Layout* layout)
1147 {
1148   // We finalize the symbols defined in SECTIONS first, because they
1149   // are the ones which may have changed.  This way if symbol outside
1150   // SECTIONS are defined in terms of symbols inside SECTIONS, they
1151   // will get the right value.
1152   this->script_sections_.finalize_symbols(symtab, layout);
1153
1154   for (Symbol_assignments::iterator p = this->symbol_assignments_.begin();
1155        p != this->symbol_assignments_.end();
1156        ++p)
1157     (*p)->finalize(symtab, layout);
1158
1159   for (Assertions::iterator p = this->assertions_.begin();
1160        p != this->assertions_.end();
1161        ++p)
1162     (*p)->check(symtab, layout);
1163 }
1164
1165 // Set section addresses.  We set all the symbols which have absolute
1166 // values.  Then we let the SECTIONS clause do its thing.  This
1167 // returns the segment which holds the file header and segment
1168 // headers, if any.
1169
1170 Output_segment*
1171 Script_options::set_section_addresses(Symbol_table* symtab, Layout* layout)
1172 {
1173   for (Symbol_assignments::iterator p = this->symbol_assignments_.begin();
1174        p != this->symbol_assignments_.end();
1175        ++p)
1176     (*p)->set_if_absolute(symtab, layout, false, 0);
1177
1178   return this->script_sections_.set_section_addresses(symtab, layout);
1179 }
1180
1181 // This class holds data passed through the parser to the lexer and to
1182 // the parser support functions.  This avoids global variables.  We
1183 // can't use global variables because we need not be called by a
1184 // singleton thread.
1185
1186 class Parser_closure
1187 {
1188  public:
1189   Parser_closure(const char* filename,
1190                  const Position_dependent_options& posdep_options,
1191                  bool parsing_defsym, bool in_group, bool is_in_sysroot,
1192                  Command_line* command_line,
1193                  Script_options* script_options,
1194                  Lex* lex,
1195                  bool skip_on_incompatible_target)
1196     : filename_(filename), posdep_options_(posdep_options),
1197       parsing_defsym_(parsing_defsym), in_group_(in_group),
1198       is_in_sysroot_(is_in_sysroot),
1199       skip_on_incompatible_target_(skip_on_incompatible_target),
1200       found_incompatible_target_(false),
1201       command_line_(command_line), script_options_(script_options),
1202       version_script_info_(script_options->version_script_info()),
1203       lex_(lex), lineno_(0), charpos_(0), lex_mode_stack_(), inputs_(NULL)
1204   {
1205     // We start out processing C symbols in the default lex mode.
1206     this->language_stack_.push_back(Version_script_info::LANGUAGE_C);
1207     this->lex_mode_stack_.push_back(lex->mode());
1208   }
1209
1210   // Return the file name.
1211   const char*
1212   filename() const
1213   { return this->filename_; }
1214
1215   // Return the position dependent options.  The caller may modify
1216   // this.
1217   Position_dependent_options&
1218   position_dependent_options()
1219   { return this->posdep_options_; }
1220
1221   // Whether we are parsing a --defsym.
1222   bool
1223   parsing_defsym() const
1224   { return this->parsing_defsym_; }
1225
1226   // Return whether this script is being run in a group.
1227   bool
1228   in_group() const
1229   { return this->in_group_; }
1230
1231   // Return whether this script was found using a directory in the
1232   // sysroot.
1233   bool
1234   is_in_sysroot() const
1235   { return this->is_in_sysroot_; }
1236
1237   // Whether to skip to the next file with the same name if we find an
1238   // incompatible target in an OUTPUT_FORMAT statement.
1239   bool
1240   skip_on_incompatible_target() const
1241   { return this->skip_on_incompatible_target_; }
1242
1243   // Stop skipping to the next file on an incompatible target.  This
1244   // is called when we make some unrevocable change to the data
1245   // structures.
1246   void
1247   clear_skip_on_incompatible_target()
1248   { this->skip_on_incompatible_target_ = false; }
1249
1250   // Whether we found an incompatible target in an OUTPUT_FORMAT
1251   // statement.
1252   bool
1253   found_incompatible_target() const
1254   { return this->found_incompatible_target_; }
1255
1256   // Note that we found an incompatible target.
1257   void
1258   set_found_incompatible_target()
1259   { this->found_incompatible_target_ = true; }
1260
1261   // Returns the Command_line structure passed in at constructor time.
1262   // This value may be NULL.  The caller may modify this, which modifies
1263   // the passed-in Command_line object (not a copy).
1264   Command_line*
1265   command_line()
1266   { return this->command_line_; }
1267
1268   // Return the options which may be set by a script.
1269   Script_options*
1270   script_options()
1271   { return this->script_options_; }
1272
1273   // Return the object in which version script information should be stored.
1274   Version_script_info*
1275   version_script()
1276   { return this->version_script_info_; }
1277
1278   // Return the next token, and advance.
1279   const Token*
1280   next_token()
1281   {
1282     const Token* token = this->lex_->next_token();
1283     this->lineno_ = token->lineno();
1284     this->charpos_ = token->charpos();
1285     return token;
1286   }
1287
1288   // Set a new lexer mode, pushing the current one.
1289   void
1290   push_lex_mode(Lex::Mode mode)
1291   {
1292     this->lex_mode_stack_.push_back(this->lex_->mode());
1293     this->lex_->set_mode(mode);
1294   }
1295
1296   // Pop the lexer mode.
1297   void
1298   pop_lex_mode()
1299   {
1300     gold_assert(!this->lex_mode_stack_.empty());
1301     this->lex_->set_mode(this->lex_mode_stack_.back());
1302     this->lex_mode_stack_.pop_back();
1303   }
1304
1305   // Return the current lexer mode.
1306   Lex::Mode
1307   lex_mode() const
1308   { return this->lex_mode_stack_.back(); }
1309
1310   // Return the line number of the last token.
1311   int
1312   lineno() const
1313   { return this->lineno_; }
1314
1315   // Return the character position in the line of the last token.
1316   int
1317   charpos() const
1318   { return this->charpos_; }
1319
1320   // Return the list of input files, creating it if necessary.  This
1321   // is a space leak--we never free the INPUTS_ pointer.
1322   Input_arguments*
1323   inputs()
1324   {
1325     if (this->inputs_ == NULL)
1326       this->inputs_ = new Input_arguments();
1327     return this->inputs_;
1328   }
1329
1330   // Return whether we saw any input files.
1331   bool
1332   saw_inputs() const
1333   { return this->inputs_ != NULL && !this->inputs_->empty(); }
1334
1335   // Return the current language being processed in a version script
1336   // (eg, "C++").  The empty string represents unmangled C names.
1337   Version_script_info::Language
1338   get_current_language() const
1339   { return this->language_stack_.back(); }
1340
1341   // Push a language onto the stack when entering an extern block.
1342   void
1343   push_language(Version_script_info::Language lang)
1344   { this->language_stack_.push_back(lang); }
1345
1346   // Pop a language off of the stack when exiting an extern block.
1347   void
1348   pop_language()
1349   {
1350     gold_assert(!this->language_stack_.empty());
1351     this->language_stack_.pop_back();
1352   }
1353
1354  private:
1355   // The name of the file we are reading.
1356   const char* filename_;
1357   // The position dependent options.
1358   Position_dependent_options posdep_options_;
1359   // True if we are parsing a --defsym.
1360   bool parsing_defsym_;
1361   // Whether we are currently in a --start-group/--end-group.
1362   bool in_group_;
1363   // Whether the script was found in a sysrooted directory.
1364   bool is_in_sysroot_;
1365   // If this is true, then if we find an OUTPUT_FORMAT with an
1366   // incompatible target, then we tell the parser to abort so that we
1367   // can search for the next file with the same name.
1368   bool skip_on_incompatible_target_;
1369   // True if we found an OUTPUT_FORMAT with an incompatible target.
1370   bool found_incompatible_target_;
1371   // May be NULL if the user chooses not to pass one in.
1372   Command_line* command_line_;
1373   // Options which may be set from any linker script.
1374   Script_options* script_options_;
1375   // Information parsed from a version script.
1376   Version_script_info* version_script_info_;
1377   // The lexer.
1378   Lex* lex_;
1379   // The line number of the last token returned by next_token.
1380   int lineno_;
1381   // The column number of the last token returned by next_token.
1382   int charpos_;
1383   // A stack of lexer modes.
1384   std::vector<Lex::Mode> lex_mode_stack_;
1385   // A stack of which extern/language block we're inside. Can be C++,
1386   // java, or empty for C.
1387   std::vector<Version_script_info::Language> language_stack_;
1388   // New input files found to add to the link.
1389   Input_arguments* inputs_;
1390 };
1391
1392 // FILE was found as an argument on the command line.  Try to read it
1393 // as a script.  Return true if the file was handled.
1394
1395 bool
1396 read_input_script(Workqueue* workqueue, Symbol_table* symtab, Layout* layout,
1397                   Dirsearch* dirsearch, int dirindex,
1398                   Input_objects* input_objects, Mapfile* mapfile,
1399                   Input_group* input_group,
1400                   const Input_argument* input_argument,
1401                   Input_file* input_file, Task_token* next_blocker,
1402                   bool* used_next_blocker)
1403 {
1404   *used_next_blocker = false;
1405
1406   std::string input_string;
1407   Lex::read_file(input_file, &input_string);
1408
1409   Lex lex(input_string.c_str(), input_string.length(), PARSING_LINKER_SCRIPT);
1410
1411   Parser_closure closure(input_file->filename().c_str(),
1412                          input_argument->file().options(),
1413                          false,
1414                          input_group != NULL,
1415                          input_file->is_in_sysroot(),
1416                          NULL,
1417                          layout->script_options(),
1418                          &lex,
1419                          input_file->will_search_for());
1420
1421   bool old_saw_sections_clause =
1422     layout->script_options()->saw_sections_clause();
1423
1424   if (yyparse(&closure) != 0)
1425     {
1426       if (closure.found_incompatible_target())
1427         {
1428           Read_symbols::incompatible_warning(input_argument, input_file);
1429           Read_symbols::requeue(workqueue, input_objects, symtab, layout,
1430                                 dirsearch, dirindex, mapfile, input_argument,
1431                                 input_group, next_blocker);
1432           return true;
1433         }
1434       return false;
1435     }
1436
1437   if (!old_saw_sections_clause
1438       && layout->script_options()->saw_sections_clause()
1439       && layout->have_added_input_section())
1440     gold_error(_("%s: SECTIONS seen after other input files; try -T/--script"),
1441                input_file->filename().c_str());
1442
1443   if (!closure.saw_inputs())
1444     return true;
1445
1446   Task_token* this_blocker = NULL;
1447   for (Input_arguments::const_iterator p = closure.inputs()->begin();
1448        p != closure.inputs()->end();
1449        ++p)
1450     {
1451       Task_token* nb;
1452       if (p + 1 == closure.inputs()->end())
1453         nb = next_blocker;
1454       else
1455         {
1456           nb = new Task_token(true);
1457           nb->add_blocker();
1458         }
1459       workqueue->queue_soon(new Read_symbols(input_objects, symtab,
1460                                              layout, dirsearch, 0, mapfile, &*p,
1461                                              input_group, NULL, this_blocker, nb));
1462       this_blocker = nb;
1463     }
1464
1465   if (layout->incremental_inputs() != NULL)
1466     {
1467       // Like new Read_symbols(...) above, we rely on closure.inputs()
1468       // getting leaked by closure.
1469       const std::string& filename = input_file->filename();
1470       Script_info* info = new Script_info(closure.inputs());
1471       Timespec mtime = input_file->file().get_mtime();
1472       layout->incremental_inputs()->report_script(filename, info, mtime);
1473     }
1474
1475   *used_next_blocker = true;
1476
1477   return true;
1478 }
1479
1480 // Helper function for read_version_script() and
1481 // read_commandline_script().  Processes the given file in the mode
1482 // indicated by first_token and lex_mode.
1483
1484 static bool
1485 read_script_file(const char* filename, Command_line* cmdline,
1486                  Script_options* script_options,
1487                  int first_token, Lex::Mode lex_mode)
1488 {
1489   // TODO: if filename is a relative filename, search for it manually
1490   // using "." + cmdline->options()->search_path() -- not dirsearch.
1491   Dirsearch dirsearch;
1492
1493   // The file locking code wants to record a Task, but we haven't
1494   // started the workqueue yet.  This is only for debugging purposes,
1495   // so we invent a fake value.
1496   const Task* task = reinterpret_cast<const Task*>(-1);
1497
1498   // We don't want this file to be opened in binary mode.
1499   Position_dependent_options posdep = cmdline->position_dependent_options();
1500   if (posdep.format_enum() == General_options::OBJECT_FORMAT_BINARY)
1501     posdep.set_format_enum(General_options::OBJECT_FORMAT_ELF);
1502   Input_file_argument input_argument(filename,
1503                                      Input_file_argument::INPUT_FILE_TYPE_FILE,
1504                                      "", false, posdep);
1505   Input_file input_file(&input_argument);
1506   int dummy = 0;
1507   if (!input_file.open(dirsearch, task, &dummy))
1508     return false;
1509
1510   std::string input_string;
1511   Lex::read_file(&input_file, &input_string);
1512
1513   Lex lex(input_string.c_str(), input_string.length(), first_token);
1514   lex.set_mode(lex_mode);
1515
1516   Parser_closure closure(filename,
1517                          cmdline->position_dependent_options(),
1518                          first_token == Lex::DYNAMIC_LIST,
1519                          false,
1520                          input_file.is_in_sysroot(),
1521                          cmdline,
1522                          script_options,
1523                          &lex,
1524                          false);
1525   if (yyparse(&closure) != 0)
1526     {
1527       input_file.file().unlock(task);
1528       return false;
1529     }
1530
1531   input_file.file().unlock(task);
1532
1533   gold_assert(!closure.saw_inputs());
1534
1535   return true;
1536 }
1537
1538 // FILENAME was found as an argument to --script (-T).
1539 // Read it as a script, and execute its contents immediately.
1540
1541 bool
1542 read_commandline_script(const char* filename, Command_line* cmdline)
1543 {
1544   return read_script_file(filename, cmdline, &cmdline->script_options(),
1545                           PARSING_LINKER_SCRIPT, Lex::LINKER_SCRIPT);
1546 }
1547
1548 // FILENAME was found as an argument to --version-script.  Read it as
1549 // a version script, and store its contents in
1550 // cmdline->script_options()->version_script_info().
1551
1552 bool
1553 read_version_script(const char* filename, Command_line* cmdline)
1554 {
1555   return read_script_file(filename, cmdline, &cmdline->script_options(),
1556                           PARSING_VERSION_SCRIPT, Lex::VERSION_SCRIPT);
1557 }
1558
1559 // FILENAME was found as an argument to --dynamic-list.  Read it as a
1560 // list of symbols, and store its contents in DYNAMIC_LIST.
1561
1562 bool
1563 read_dynamic_list(const char* filename, Command_line* cmdline,
1564                   Script_options* dynamic_list)
1565 {
1566   return read_script_file(filename, cmdline, dynamic_list,
1567                           PARSING_DYNAMIC_LIST, Lex::DYNAMIC_LIST);
1568 }
1569
1570 // Implement the --defsym option on the command line.  Return true if
1571 // all is well.
1572
1573 bool
1574 Script_options::define_symbol(const char* definition)
1575 {
1576   Lex lex(definition, strlen(definition), PARSING_DEFSYM);
1577   lex.set_mode(Lex::EXPRESSION);
1578
1579   // Dummy value.
1580   Position_dependent_options posdep_options;
1581
1582   Parser_closure closure("command line", posdep_options, true,
1583                          false, false, NULL, this, &lex, false);
1584
1585   if (yyparse(&closure) != 0)
1586     return false;
1587
1588   gold_assert(!closure.saw_inputs());
1589
1590   return true;
1591 }
1592
1593 // Print the script to F for debugging.
1594
1595 void
1596 Script_options::print(FILE* f) const
1597 {
1598   fprintf(f, "%s: Dumping linker script\n", program_name);
1599
1600   if (!this->entry_.empty())
1601     fprintf(f, "ENTRY(%s)\n", this->entry_.c_str());
1602
1603   for (Symbol_assignments::const_iterator p =
1604          this->symbol_assignments_.begin();
1605        p != this->symbol_assignments_.end();
1606        ++p)
1607     (*p)->print(f);
1608
1609   for (Assertions::const_iterator p = this->assertions_.begin();
1610        p != this->assertions_.end();
1611        ++p)
1612     (*p)->print(f);
1613
1614   this->script_sections_.print(f);
1615
1616   this->version_script_info_.print(f);
1617 }
1618
1619 // Manage mapping from keywords to the codes expected by the bison
1620 // parser.  We construct one global object for each lex mode with
1621 // keywords.
1622
1623 class Keyword_to_parsecode
1624 {
1625  public:
1626   // The structure which maps keywords to parsecodes.
1627   struct Keyword_parsecode
1628   {
1629     // Keyword.
1630     const char* keyword;
1631     // Corresponding parsecode.
1632     int parsecode;
1633   };
1634
1635   Keyword_to_parsecode(const Keyword_parsecode* keywords,
1636                        int keyword_count)
1637       : keyword_parsecodes_(keywords), keyword_count_(keyword_count)
1638   { }
1639
1640   // Return the parsecode corresponding KEYWORD, or 0 if it is not a
1641   // keyword.
1642   int
1643   keyword_to_parsecode(const char* keyword, size_t len) const;
1644
1645  private:
1646   const Keyword_parsecode* keyword_parsecodes_;
1647   const int keyword_count_;
1648 };
1649
1650 // Mapping from keyword string to keyword parsecode.  This array must
1651 // be kept in sorted order.  Parsecodes are looked up using bsearch.
1652 // This array must correspond to the list of parsecodes in yyscript.y.
1653
1654 static const Keyword_to_parsecode::Keyword_parsecode
1655 script_keyword_parsecodes[] =
1656 {
1657   { "ABSOLUTE", ABSOLUTE },
1658   { "ADDR", ADDR },
1659   { "ALIGN", ALIGN_K },
1660   { "ALIGNOF", ALIGNOF },
1661   { "ASSERT", ASSERT_K },
1662   { "AS_NEEDED", AS_NEEDED },
1663   { "AT", AT },
1664   { "BIND", BIND },
1665   { "BLOCK", BLOCK },
1666   { "BYTE", BYTE },
1667   { "CONSTANT", CONSTANT },
1668   { "CONSTRUCTORS", CONSTRUCTORS },
1669   { "COPY", COPY },
1670   { "CREATE_OBJECT_SYMBOLS", CREATE_OBJECT_SYMBOLS },
1671   { "DATA_SEGMENT_ALIGN", DATA_SEGMENT_ALIGN },
1672   { "DATA_SEGMENT_END", DATA_SEGMENT_END },
1673   { "DATA_SEGMENT_RELRO_END", DATA_SEGMENT_RELRO_END },
1674   { "DEFINED", DEFINED },
1675   { "DSECT", DSECT },
1676   { "ENTRY", ENTRY },
1677   { "EXCLUDE_FILE", EXCLUDE_FILE },
1678   { "EXTERN", EXTERN },
1679   { "FILL", FILL },
1680   { "FLOAT", FLOAT },
1681   { "FORCE_COMMON_ALLOCATION", FORCE_COMMON_ALLOCATION },
1682   { "GROUP", GROUP },
1683   { "HLL", HLL },
1684   { "INCLUDE", INCLUDE },
1685   { "INFO", INFO },
1686   { "INHIBIT_COMMON_ALLOCATION", INHIBIT_COMMON_ALLOCATION },
1687   { "INPUT", INPUT },
1688   { "KEEP", KEEP },
1689   { "LENGTH", LENGTH },
1690   { "LOADADDR", LOADADDR },
1691   { "LONG", LONG },
1692   { "MAP", MAP },
1693   { "MAX", MAX_K },
1694   { "MEMORY", MEMORY },
1695   { "MIN", MIN_K },
1696   { "NEXT", NEXT },
1697   { "NOCROSSREFS", NOCROSSREFS },
1698   { "NOFLOAT", NOFLOAT },
1699   { "NOLOAD", NOLOAD },
1700   { "ONLY_IF_RO", ONLY_IF_RO },
1701   { "ONLY_IF_RW", ONLY_IF_RW },
1702   { "OPTION", OPTION },
1703   { "ORIGIN", ORIGIN },
1704   { "OUTPUT", OUTPUT },
1705   { "OUTPUT_ARCH", OUTPUT_ARCH },
1706   { "OUTPUT_FORMAT", OUTPUT_FORMAT },
1707   { "OVERLAY", OVERLAY },
1708   { "PHDRS", PHDRS },
1709   { "PROVIDE", PROVIDE },
1710   { "PROVIDE_HIDDEN", PROVIDE_HIDDEN },
1711   { "QUAD", QUAD },
1712   { "SEARCH_DIR", SEARCH_DIR },
1713   { "SECTIONS", SECTIONS },
1714   { "SEGMENT_START", SEGMENT_START },
1715   { "SHORT", SHORT },
1716   { "SIZEOF", SIZEOF },
1717   { "SIZEOF_HEADERS", SIZEOF_HEADERS },
1718   { "SORT", SORT_BY_NAME },
1719   { "SORT_BY_ALIGNMENT", SORT_BY_ALIGNMENT },
1720   { "SORT_BY_NAME", SORT_BY_NAME },
1721   { "SPECIAL", SPECIAL },
1722   { "SQUAD", SQUAD },
1723   { "STARTUP", STARTUP },
1724   { "SUBALIGN", SUBALIGN },
1725   { "SYSLIB", SYSLIB },
1726   { "TARGET", TARGET_K },
1727   { "TRUNCATE", TRUNCATE },
1728   { "VERSION", VERSIONK },
1729   { "global", GLOBAL },
1730   { "l", LENGTH },
1731   { "len", LENGTH },
1732   { "local", LOCAL },
1733   { "o", ORIGIN },
1734   { "org", ORIGIN },
1735   { "sizeof_headers", SIZEOF_HEADERS },
1736 };
1737
1738 static const Keyword_to_parsecode
1739 script_keywords(&script_keyword_parsecodes[0],
1740                 (sizeof(script_keyword_parsecodes)
1741                  / sizeof(script_keyword_parsecodes[0])));
1742
1743 static const Keyword_to_parsecode::Keyword_parsecode
1744 version_script_keyword_parsecodes[] =
1745 {
1746   { "extern", EXTERN },
1747   { "global", GLOBAL },
1748   { "local", LOCAL },
1749 };
1750
1751 static const Keyword_to_parsecode
1752 version_script_keywords(&version_script_keyword_parsecodes[0],
1753                         (sizeof(version_script_keyword_parsecodes)
1754                          / sizeof(version_script_keyword_parsecodes[0])));
1755
1756 static const Keyword_to_parsecode::Keyword_parsecode
1757 dynamic_list_keyword_parsecodes[] =
1758 {
1759   { "extern", EXTERN },
1760 };
1761
1762 static const Keyword_to_parsecode
1763 dynamic_list_keywords(&dynamic_list_keyword_parsecodes[0],
1764                       (sizeof(dynamic_list_keyword_parsecodes)
1765                        / sizeof(dynamic_list_keyword_parsecodes[0])));
1766
1767
1768
1769 // Comparison function passed to bsearch.
1770
1771 extern "C"
1772 {
1773
1774 struct Ktt_key
1775 {
1776   const char* str;
1777   size_t len;
1778 };
1779
1780 static int
1781 ktt_compare(const void* keyv, const void* kttv)
1782 {
1783   const Ktt_key* key = static_cast<const Ktt_key*>(keyv);
1784   const Keyword_to_parsecode::Keyword_parsecode* ktt =
1785     static_cast<const Keyword_to_parsecode::Keyword_parsecode*>(kttv);
1786   int i = strncmp(key->str, ktt->keyword, key->len);
1787   if (i != 0)
1788     return i;
1789   if (ktt->keyword[key->len] != '\0')
1790     return -1;
1791   return 0;
1792 }
1793
1794 } // End extern "C".
1795
1796 int
1797 Keyword_to_parsecode::keyword_to_parsecode(const char* keyword,
1798                                            size_t len) const
1799 {
1800   Ktt_key key;
1801   key.str = keyword;
1802   key.len = len;
1803   void* kttv = bsearch(&key,
1804                        this->keyword_parsecodes_,
1805                        this->keyword_count_,
1806                        sizeof(this->keyword_parsecodes_[0]),
1807                        ktt_compare);
1808   if (kttv == NULL)
1809     return 0;
1810   Keyword_parsecode* ktt = static_cast<Keyword_parsecode*>(kttv);
1811   return ktt->parsecode;
1812 }
1813
1814 // The following structs are used within the VersionInfo class as well
1815 // as in the bison helper functions.  They store the information
1816 // parsed from the version script.
1817
1818 // A single version expression.
1819 // For example, pattern="std::map*" and language="C++".
1820 struct Version_expression
1821 {
1822   Version_expression(const std::string& a_pattern,
1823                      Version_script_info::Language a_language,
1824                      bool a_exact_match)
1825     : pattern(a_pattern), language(a_language), exact_match(a_exact_match),
1826       was_matched_by_symbol(false)
1827   { }
1828
1829   std::string pattern;
1830   Version_script_info::Language language;
1831   // If false, we use glob() to match pattern.  If true, we use strcmp().
1832   bool exact_match;
1833   // True if --no-undefined-version is in effect and we found this
1834   // version in get_symbol_version.  We use mutable because this
1835   // struct is generally not modifiable after it has been created.
1836   mutable bool was_matched_by_symbol;
1837 };
1838
1839 // A list of expressions.
1840 struct Version_expression_list
1841 {
1842   std::vector<struct Version_expression> expressions;
1843 };
1844
1845 // A list of which versions upon which another version depends.
1846 // Strings should be from the Stringpool.
1847 struct Version_dependency_list
1848 {
1849   std::vector<std::string> dependencies;
1850 };
1851
1852 // The total definition of a version.  It includes the tag for the
1853 // version, its global and local expressions, and any dependencies.
1854 struct Version_tree
1855 {
1856   Version_tree()
1857       : tag(), global(NULL), local(NULL), dependencies(NULL)
1858   { }
1859
1860   std::string tag;
1861   const struct Version_expression_list* global;
1862   const struct Version_expression_list* local;
1863   const struct Version_dependency_list* dependencies;
1864 };
1865
1866 // Helper class that calls cplus_demangle when needed and takes care of freeing
1867 // the result.
1868
1869 class Lazy_demangler
1870 {
1871  public:
1872   Lazy_demangler(const char* symbol, int options)
1873     : symbol_(symbol), options_(options), demangled_(NULL), did_demangle_(false)
1874   { }
1875
1876   ~Lazy_demangler()
1877   { free(this->demangled_); }
1878
1879   // Return the demangled name. The actual demangling happens on the first call,
1880   // and the result is later cached.
1881   inline char*
1882   get();
1883
1884  private:
1885   // The symbol to demangle.
1886   const char* symbol_;
1887   // Option flags to pass to cplus_demagle.
1888   const int options_;
1889   // The cached demangled value, or NULL if demangling didn't happen yet or
1890   // failed.
1891   char* demangled_;
1892   // Whether we already called cplus_demangle
1893   bool did_demangle_;
1894 };
1895
1896 // Return the demangled name. The actual demangling happens on the first call,
1897 // and the result is later cached. Returns NULL if the symbol cannot be
1898 // demangled.
1899
1900 inline char*
1901 Lazy_demangler::get()
1902 {
1903   if (!this->did_demangle_)
1904     {
1905       this->demangled_ = cplus_demangle(this->symbol_, this->options_);
1906       this->did_demangle_ = true;
1907     }
1908   return this->demangled_;
1909 }
1910
1911 // Class Version_script_info.
1912
1913 Version_script_info::Version_script_info()
1914   : dependency_lists_(), expression_lists_(), version_trees_(), globs_(),
1915     default_version_(NULL), default_is_global_(false), is_finalized_(false)
1916 {
1917   for (int i = 0; i < LANGUAGE_COUNT; ++i)
1918     this->exact_[i] = NULL;
1919 }
1920
1921 Version_script_info::~Version_script_info()
1922 {
1923 }
1924
1925 // Forget all the known version script information.
1926
1927 void
1928 Version_script_info::clear()
1929 {
1930   for (size_t k = 0; k < this->dependency_lists_.size(); ++k)
1931     delete this->dependency_lists_[k];
1932   this->dependency_lists_.clear();
1933   for (size_t k = 0; k < this->version_trees_.size(); ++k)
1934     delete this->version_trees_[k];
1935   this->version_trees_.clear();
1936   for (size_t k = 0; k < this->expression_lists_.size(); ++k)
1937     delete this->expression_lists_[k];
1938   this->expression_lists_.clear();
1939 }
1940
1941 // Finalize the version script information.
1942
1943 void
1944 Version_script_info::finalize()
1945 {
1946   if (!this->is_finalized_)
1947     {
1948       this->build_lookup_tables();
1949       this->is_finalized_ = true;
1950     }
1951 }
1952
1953 // Return all the versions.
1954
1955 std::vector<std::string>
1956 Version_script_info::get_versions() const
1957 {
1958   std::vector<std::string> ret;
1959   for (size_t j = 0; j < this->version_trees_.size(); ++j)
1960     if (!this->version_trees_[j]->tag.empty())
1961       ret.push_back(this->version_trees_[j]->tag);
1962   return ret;
1963 }
1964
1965 // Return the dependencies of VERSION.
1966
1967 std::vector<std::string>
1968 Version_script_info::get_dependencies(const char* version) const
1969 {
1970   std::vector<std::string> ret;
1971   for (size_t j = 0; j < this->version_trees_.size(); ++j)
1972     if (this->version_trees_[j]->tag == version)
1973       {
1974         const struct Version_dependency_list* deps =
1975           this->version_trees_[j]->dependencies;
1976         if (deps != NULL)
1977           for (size_t k = 0; k < deps->dependencies.size(); ++k)
1978             ret.push_back(deps->dependencies[k]);
1979         return ret;
1980       }
1981   return ret;
1982 }
1983
1984 // A version script essentially maps a symbol name to a version tag
1985 // and an indication of whether symbol is global or local within that
1986 // version tag.  Each symbol maps to at most one version tag.
1987 // Unfortunately, in practice, version scripts are ambiguous, and list
1988 // symbols multiple times.  Thus, we have to document the matching
1989 // process.
1990
1991 // This is a description of what the GNU linker does as of 2010-01-11.
1992 // It walks through the version tags in the order in which they appear
1993 // in the version script.  For each tag, it first walks through the
1994 // global patterns for that tag, then the local patterns.  When
1995 // looking at a single pattern, it first applies any language specific
1996 // demangling as specified for the pattern, and then matches the
1997 // resulting symbol name to the pattern.  If it finds an exact match
1998 // for a literal pattern (a pattern enclosed in quotes or with no
1999 // wildcard characters), then that is the match that it uses.  If
2000 // finds a match with a wildcard pattern, then it saves it and
2001 // continues searching.  Wildcard patterns that are exactly "*" are
2002 // saved separately.
2003
2004 // If no exact match with a literal pattern is ever found, then if a
2005 // wildcard match with a global pattern was found it is used,
2006 // otherwise if a wildcard match with a local pattern was found it is
2007 // used.
2008
2009 // This is the result:
2010 //   * If there is an exact match, then we use the first tag in the
2011 //     version script where it matches.
2012 //     + If the exact match in that tag is global, it is used.
2013 //     + Otherwise the exact match in that tag is local, and is used.
2014 //   * Otherwise, if there is any match with a global wildcard pattern:
2015 //     + If there is any match with a wildcard pattern which is not
2016 //       "*", then we use the tag in which the *last* such pattern
2017 //       appears.
2018 //     + Otherwise, we matched "*".  If there is no match with a local
2019 //       wildcard pattern which is not "*", then we use the *last*
2020 //       match with a global "*".  Otherwise, continue.
2021 //   * Otherwise, if there is any match with a local wildcard pattern:
2022 //     + If there is any match with a wildcard pattern which is not
2023 //       "*", then we use the tag in which the *last* such pattern
2024 //       appears.
2025 //     + Otherwise, we matched "*", and we use the tag in which the
2026 //       *last* such match occurred.
2027
2028 // There is an additional wrinkle.  When the GNU linker finds a symbol
2029 // with a version defined in an object file due to a .symver
2030 // directive, it looks up that symbol name in that version tag.  If it
2031 // finds it, it matches the symbol name against the patterns for that
2032 // version.  If there is no match with a global pattern, but there is
2033 // a match with a local pattern, then the GNU linker marks the symbol
2034 // as local.
2035
2036 // We want gold to be generally compatible, but we also want gold to
2037 // be fast.  These are the rules that gold implements:
2038 //   * If there is an exact match for the mangled name, we use it.
2039 //     + If there is more than one exact match, we give a warning, and
2040 //       we use the first tag in the script which matches.
2041 //     + If a symbol has an exact match as both global and local for
2042 //       the same version tag, we give an error.
2043 //   * Otherwise, we look for an extern C++ or an extern Java exact
2044 //     match.  If we find an exact match, we use it.
2045 //     + If there is more than one exact match, we give a warning, and
2046 //       we use the first tag in the script which matches.
2047 //     + If a symbol has an exact match as both global and local for
2048 //       the same version tag, we give an error.
2049 //   * Otherwise, we look through the wildcard patterns, ignoring "*"
2050 //     patterns.  We look through the version tags in reverse order.
2051 //     For each version tag, we look through the global patterns and
2052 //     then the local patterns.  We use the first match we find (i.e.,
2053 //     the last matching version tag in the file).
2054 //   * Otherwise, we use the "*" pattern if there is one.  We give an
2055 //     error if there are multiple "*" patterns.
2056
2057 // At least for now, gold does not look up the version tag for a
2058 // symbol version found in an object file to see if it should be
2059 // forced local.  There are other ways to force a symbol to be local,
2060 // and I don't understand why this one is useful.
2061
2062 // Build a set of fast lookup tables for a version script.
2063
2064 void
2065 Version_script_info::build_lookup_tables()
2066 {
2067   size_t size = this->version_trees_.size();
2068   for (size_t j = 0; j < size; ++j)
2069     {
2070       const Version_tree* v = this->version_trees_[j];
2071       this->build_expression_list_lookup(v->local, v, false);
2072       this->build_expression_list_lookup(v->global, v, true);
2073     }
2074 }
2075
2076 // If a pattern has backlashes but no unquoted wildcard characters,
2077 // then we apply backslash unquoting and look for an exact match.
2078 // Otherwise we treat it as a wildcard pattern.  This function returns
2079 // true for a wildcard pattern.  Otherwise, it does backslash
2080 // unquoting on *PATTERN and returns false.  If this returns true,
2081 // *PATTERN may have been partially unquoted.
2082
2083 bool
2084 Version_script_info::unquote(std::string* pattern) const
2085 {
2086   bool saw_backslash = false;
2087   size_t len = pattern->length();
2088   size_t j = 0;
2089   for (size_t i = 0; i < len; ++i)
2090     {
2091       if (saw_backslash)
2092         saw_backslash = false;
2093       else
2094         {
2095           switch ((*pattern)[i])
2096             {
2097             case '?': case '[': case '*':
2098               return true;
2099             case '\\':
2100               saw_backslash = true;
2101               continue;
2102             default:
2103               break;
2104             }
2105         }
2106
2107       if (i != j)
2108         (*pattern)[j] = (*pattern)[i];
2109       ++j;
2110     }
2111   return false;
2112 }
2113
2114 // Add an exact match for MATCH to *PE.  The result of the match is
2115 // V/IS_GLOBAL.
2116
2117 void
2118 Version_script_info::add_exact_match(const std::string& match,
2119                                      const Version_tree* v, bool is_global,
2120                                      const Version_expression* ve,
2121                                      Exact* pe)
2122 {
2123   std::pair<Exact::iterator, bool> ins =
2124     pe->insert(std::make_pair(match, Version_tree_match(v, is_global, ve)));
2125   if (ins.second)
2126     {
2127       // This is the first time we have seen this match.
2128       return;
2129     }
2130
2131   Version_tree_match& vtm(ins.first->second);
2132   if (vtm.real->tag != v->tag)
2133     {
2134       // This is an ambiguous match.  We still return the
2135       // first version that we found in the script, but we
2136       // record the new version to issue a warning if we
2137       // wind up looking up this symbol.
2138       if (vtm.ambiguous == NULL)
2139         vtm.ambiguous = v;
2140     }
2141   else if (is_global != vtm.is_global)
2142     {
2143       // We have a match for both the global and local entries for a
2144       // version tag.  That's got to be wrong.
2145       gold_error(_("'%s' appears as both a global and a local symbol "
2146                    "for version '%s' in script"),
2147                  match.c_str(), v->tag.c_str());
2148     }
2149 }
2150
2151 // Build fast lookup information for EXPLIST and store it in LOOKUP.
2152 // All matches go to V, and IS_GLOBAL is true if they are global
2153 // matches.
2154
2155 void
2156 Version_script_info::build_expression_list_lookup(
2157     const Version_expression_list* explist,
2158     const Version_tree* v,
2159     bool is_global)
2160 {
2161   if (explist == NULL)
2162     return;
2163   size_t size = explist->expressions.size();
2164   for (size_t i = 0; i < size; ++i)
2165     {
2166       const Version_expression& exp(explist->expressions[i]);
2167
2168       if (exp.pattern.length() == 1 && exp.pattern[0] == '*')
2169         {
2170           if (this->default_version_ != NULL
2171               && this->default_version_->tag != v->tag)
2172             gold_warning(_("wildcard match appears in both version '%s' "
2173                            "and '%s' in script"),
2174                          this->default_version_->tag.c_str(), v->tag.c_str());
2175           else if (this->default_version_ != NULL
2176                    && this->default_is_global_ != is_global)
2177             gold_error(_("wildcard match appears as both global and local "
2178                          "in version '%s' in script"),
2179                        v->tag.c_str());
2180           this->default_version_ = v;
2181           this->default_is_global_ = is_global;
2182           continue;
2183         }
2184
2185       std::string pattern = exp.pattern;
2186       if (!exp.exact_match)
2187         {
2188           if (this->unquote(&pattern))
2189             {
2190               this->globs_.push_back(Glob(&exp, v, is_global));
2191               continue;
2192             }
2193         }
2194
2195       if (this->exact_[exp.language] == NULL)
2196         this->exact_[exp.language] = new Exact();
2197       this->add_exact_match(pattern, v, is_global, &exp,
2198                             this->exact_[exp.language]);
2199     }
2200 }
2201
2202 // Return the name to match given a name, a language code, and two
2203 // lazy demanglers.
2204
2205 const char*
2206 Version_script_info::get_name_to_match(const char* name,
2207                                        int language,
2208                                        Lazy_demangler* cpp_demangler,
2209                                        Lazy_demangler* java_demangler) const
2210 {
2211   switch (language)
2212     {
2213     case LANGUAGE_C:
2214       return name;
2215     case LANGUAGE_CXX:
2216       return cpp_demangler->get();
2217     case LANGUAGE_JAVA:
2218       return java_demangler->get();
2219     default:
2220       gold_unreachable();
2221     }
2222 }
2223
2224 // Look up SYMBOL_NAME in the list of versions.  Return true if the
2225 // symbol is found, false if not.  If the symbol is found, then if
2226 // PVERSION is not NULL, set *PVERSION to the version tag, and if
2227 // P_IS_GLOBAL is not NULL, set *P_IS_GLOBAL according to whether the
2228 // symbol is global or not.
2229
2230 bool
2231 Version_script_info::get_symbol_version(const char* symbol_name,
2232                                         std::string* pversion,
2233                                         bool* p_is_global) const
2234 {
2235   Lazy_demangler cpp_demangled_name(symbol_name, DMGL_ANSI | DMGL_PARAMS);
2236   Lazy_demangler java_demangled_name(symbol_name,
2237                                      DMGL_ANSI | DMGL_PARAMS | DMGL_JAVA);
2238
2239   gold_assert(this->is_finalized_);
2240   for (int i = 0; i < LANGUAGE_COUNT; ++i)
2241     {
2242       Exact* exact = this->exact_[i];
2243       if (exact == NULL)
2244         continue;
2245
2246       const char* name_to_match = this->get_name_to_match(symbol_name, i,
2247                                                           &cpp_demangled_name,
2248                                                           &java_demangled_name);
2249       if (name_to_match == NULL)
2250         {
2251           // If the name can not be demangled, the GNU linker goes
2252           // ahead and tries to match it anyhow.  That does not
2253           // make sense to me and I have not implemented it.
2254           continue;
2255         }
2256
2257       Exact::const_iterator pe = exact->find(name_to_match);
2258       if (pe != exact->end())
2259         {
2260           const Version_tree_match& vtm(pe->second);
2261           if (vtm.ambiguous != NULL)
2262             gold_warning(_("using '%s' as version for '%s' which is also "
2263                            "named in version '%s' in script"),
2264                          vtm.real->tag.c_str(), name_to_match,
2265                          vtm.ambiguous->tag.c_str());
2266
2267           if (pversion != NULL)
2268             *pversion = vtm.real->tag;
2269           if (p_is_global != NULL)
2270             *p_is_global = vtm.is_global;
2271
2272           // If we are using --no-undefined-version, and this is a
2273           // global symbol, we have to record that we have found this
2274           // symbol, so that we don't warn about it.  We have to do
2275           // this now, because otherwise we have no way to get from a
2276           // non-C language back to the demangled name that we
2277           // matched.
2278           if (p_is_global != NULL && vtm.is_global)
2279             vtm.expression->was_matched_by_symbol = true;
2280
2281           return true;
2282         }
2283     }
2284
2285   // Look through the glob patterns in reverse order.
2286
2287   for (Globs::const_reverse_iterator p = this->globs_.rbegin();
2288        p != this->globs_.rend();
2289        ++p)
2290     {
2291       int language = p->expression->language;
2292       const char* name_to_match = this->get_name_to_match(symbol_name,
2293                                                           language,
2294                                                           &cpp_demangled_name,
2295                                                           &java_demangled_name);
2296       if (name_to_match == NULL)
2297         continue;
2298
2299       if (fnmatch(p->expression->pattern.c_str(), name_to_match,
2300                   FNM_NOESCAPE) == 0)
2301         {
2302           if (pversion != NULL)
2303             *pversion = p->version->tag;
2304           if (p_is_global != NULL)
2305             *p_is_global = p->is_global;
2306           return true;
2307         }
2308     }
2309
2310   // Finally, there may be a wildcard.
2311   if (this->default_version_ != NULL)
2312     {
2313       if (pversion != NULL)
2314         *pversion = this->default_version_->tag;
2315       if (p_is_global != NULL)
2316         *p_is_global = this->default_is_global_;
2317       return true;
2318     }
2319
2320   return false;
2321 }
2322
2323 // Give an error if any exact symbol names (not wildcards) appear in a
2324 // version script, but there is no such symbol.
2325
2326 void
2327 Version_script_info::check_unmatched_names(const Symbol_table* symtab) const
2328 {
2329   for (size_t i = 0; i < this->version_trees_.size(); ++i)
2330     {
2331       const Version_tree* vt = this->version_trees_[i];
2332       if (vt->global == NULL)
2333         continue;
2334       for (size_t j = 0; j < vt->global->expressions.size(); ++j)
2335         {
2336           const Version_expression& expression(vt->global->expressions[j]);
2337
2338           // Ignore cases where we used the version because we saw a
2339           // symbol that we looked up.  Note that
2340           // WAS_MATCHED_BY_SYMBOL will be true even if the symbol was
2341           // not a definition.  That's OK as in that case we most
2342           // likely gave an undefined symbol error anyhow.
2343           if (expression.was_matched_by_symbol)
2344             continue;
2345
2346           // Just ignore names which are in languages other than C.
2347           // We have no way to look them up in the symbol table.
2348           if (expression.language != LANGUAGE_C)
2349             continue;
2350
2351           // Remove backslash quoting, and ignore wildcard patterns.
2352           std::string pattern = expression.pattern;
2353           if (!expression.exact_match)
2354             {
2355               if (this->unquote(&pattern))
2356                 continue;
2357             }
2358
2359           if (symtab->lookup(pattern.c_str(), vt->tag.c_str()) == NULL)
2360             gold_error(_("version script assignment of %s to symbol %s "
2361                          "failed: symbol not defined"),
2362                        vt->tag.c_str(), pattern.c_str());
2363         }
2364     }
2365 }
2366
2367 struct Version_dependency_list*
2368 Version_script_info::allocate_dependency_list()
2369 {
2370   dependency_lists_.push_back(new Version_dependency_list);
2371   return dependency_lists_.back();
2372 }
2373
2374 struct Version_expression_list*
2375 Version_script_info::allocate_expression_list()
2376 {
2377   expression_lists_.push_back(new Version_expression_list);
2378   return expression_lists_.back();
2379 }
2380
2381 struct Version_tree*
2382 Version_script_info::allocate_version_tree()
2383 {
2384   version_trees_.push_back(new Version_tree);
2385   return version_trees_.back();
2386 }
2387
2388 // Print for debugging.
2389
2390 void
2391 Version_script_info::print(FILE* f) const
2392 {
2393   if (this->empty())
2394     return;
2395
2396   fprintf(f, "VERSION {");
2397
2398   for (size_t i = 0; i < this->version_trees_.size(); ++i)
2399     {
2400       const Version_tree* vt = this->version_trees_[i];
2401
2402       if (vt->tag.empty())
2403         fprintf(f, "  {\n");
2404       else
2405         fprintf(f, "  %s {\n", vt->tag.c_str());
2406
2407       if (vt->global != NULL)
2408         {
2409           fprintf(f, "    global :\n");
2410           this->print_expression_list(f, vt->global);
2411         }
2412
2413       if (vt->local != NULL)
2414         {
2415           fprintf(f, "    local :\n");
2416           this->print_expression_list(f, vt->local);
2417         }
2418
2419       fprintf(f, "  }");
2420       if (vt->dependencies != NULL)
2421         {
2422           const Version_dependency_list* deps = vt->dependencies;
2423           for (size_t j = 0; j < deps->dependencies.size(); ++j)
2424             {
2425               if (j < deps->dependencies.size() - 1)
2426                 fprintf(f, "\n");
2427               fprintf(f, "    %s", deps->dependencies[j].c_str());
2428             }
2429         }
2430       fprintf(f, ";\n");
2431     }
2432
2433   fprintf(f, "}\n");
2434 }
2435
2436 void
2437 Version_script_info::print_expression_list(
2438     FILE* f,
2439     const Version_expression_list* vel) const
2440 {
2441   Version_script_info::Language current_language = LANGUAGE_C;
2442   for (size_t i = 0; i < vel->expressions.size(); ++i)
2443     {
2444       const Version_expression& ve(vel->expressions[i]);
2445
2446       if (ve.language != current_language)
2447         {
2448           if (current_language != LANGUAGE_C)
2449             fprintf(f, "      }\n");
2450           switch (ve.language)
2451             {
2452             case LANGUAGE_C:
2453               break;
2454             case LANGUAGE_CXX:
2455               fprintf(f, "      extern \"C++\" {\n");
2456               break;
2457             case LANGUAGE_JAVA:
2458               fprintf(f, "      extern \"Java\" {\n");
2459               break;
2460             default:
2461               gold_unreachable();
2462             }
2463           current_language = ve.language;
2464         }
2465
2466       fprintf(f, "      ");
2467       if (current_language != LANGUAGE_C)
2468         fprintf(f, "  ");
2469
2470       if (ve.exact_match)
2471         fprintf(f, "\"");
2472       fprintf(f, "%s", ve.pattern.c_str());
2473       if (ve.exact_match)
2474         fprintf(f, "\"");
2475
2476       fprintf(f, "\n");
2477     }
2478
2479   if (current_language != LANGUAGE_C)
2480     fprintf(f, "      }\n");
2481 }
2482
2483 } // End namespace gold.
2484
2485 // The remaining functions are extern "C", so it's clearer to not put
2486 // them in namespace gold.
2487
2488 using namespace gold;
2489
2490 // This function is called by the bison parser to return the next
2491 // token.
2492
2493 extern "C" int
2494 yylex(YYSTYPE* lvalp, void* closurev)
2495 {
2496   Parser_closure* closure = static_cast<Parser_closure*>(closurev);
2497   const Token* token = closure->next_token();
2498   switch (token->classification())
2499     {
2500     default:
2501       gold_unreachable();
2502
2503     case Token::TOKEN_INVALID:
2504       yyerror(closurev, "invalid character");
2505       return 0;
2506
2507     case Token::TOKEN_EOF:
2508       return 0;
2509
2510     case Token::TOKEN_STRING:
2511       {
2512         // This is either a keyword or a STRING.
2513         size_t len;
2514         const char* str = token->string_value(&len);
2515         int parsecode = 0;
2516         switch (closure->lex_mode())
2517           {
2518           case Lex::LINKER_SCRIPT:
2519             parsecode = script_keywords.keyword_to_parsecode(str, len);
2520             break;
2521           case Lex::VERSION_SCRIPT:
2522             parsecode = version_script_keywords.keyword_to_parsecode(str, len);
2523             break;
2524           case Lex::DYNAMIC_LIST:
2525             parsecode = dynamic_list_keywords.keyword_to_parsecode(str, len);
2526             break;
2527           default:
2528             break;
2529           }
2530         if (parsecode != 0)
2531           return parsecode;
2532         lvalp->string.value = str;
2533         lvalp->string.length = len;
2534         return STRING;
2535       }
2536
2537     case Token::TOKEN_QUOTED_STRING:
2538       lvalp->string.value = token->string_value(&lvalp->string.length);
2539       return QUOTED_STRING;
2540
2541     case Token::TOKEN_OPERATOR:
2542       return token->operator_value();
2543
2544     case Token::TOKEN_INTEGER:
2545       lvalp->integer = token->integer_value();
2546       return INTEGER;
2547     }
2548 }
2549
2550 // This function is called by the bison parser to report an error.
2551
2552 extern "C" void
2553 yyerror(void* closurev, const char* message)
2554 {
2555   Parser_closure* closure = static_cast<Parser_closure*>(closurev);
2556   gold_error(_("%s:%d:%d: %s"), closure->filename(), closure->lineno(),
2557              closure->charpos(), message);
2558 }
2559
2560 // Called by the bison parser to add an external symbol to the link.
2561
2562 extern "C" void
2563 script_add_extern(void* closurev, const char* name, size_t length)
2564 {
2565   // We treat exactly like -u NAME.  FIXME: If it seems useful, we
2566   // could handle this after the command line has been read, by adding
2567   // entries to the symbol table directly.
2568   std::string arg("--undefined=");
2569   arg.append(name, length);
2570   script_parse_option(closurev, arg.c_str(), arg.size());
2571 }
2572
2573 // Called by the bison parser to add a file to the link.
2574
2575 extern "C" void
2576 script_add_file(void* closurev, const char* name, size_t length)
2577 {
2578   Parser_closure* closure = static_cast<Parser_closure*>(closurev);
2579
2580   // If this is an absolute path, and we found the script in the
2581   // sysroot, then we want to prepend the sysroot to the file name.
2582   // For example, this is how we handle a cross link to the x86_64
2583   // libc.so, which refers to /lib/libc.so.6.
2584   std::string name_string(name, length);
2585   const char* extra_search_path = ".";
2586   std::string script_directory;
2587   if (IS_ABSOLUTE_PATH(name_string.c_str()))
2588     {
2589       if (closure->is_in_sysroot())
2590         {
2591           const std::string& sysroot(parameters->options().sysroot());
2592           gold_assert(!sysroot.empty());
2593           name_string = sysroot + name_string;
2594         }
2595     }
2596   else
2597     {
2598       // In addition to checking the normal library search path, we
2599       // also want to check in the script-directory.
2600       const char* slash = strrchr(closure->filename(), '/');
2601       if (slash != NULL)
2602         {
2603           script_directory.assign(closure->filename(),
2604                                   slash - closure->filename() + 1);
2605           extra_search_path = script_directory.c_str();
2606         }
2607     }
2608
2609   Input_file_argument file(name_string.c_str(),
2610                            Input_file_argument::INPUT_FILE_TYPE_FILE,
2611                            extra_search_path, false,
2612                            closure->position_dependent_options());
2613   closure->inputs()->add_file(file);
2614 }
2615
2616 // Called by the bison parser to add a library to the link.
2617
2618 extern "C" void
2619 script_add_library(void* closurev, const char* name, size_t length)
2620 {
2621   Parser_closure* closure = static_cast<Parser_closure*>(closurev);
2622   std::string name_string(name, length);
2623
2624   if (name_string[0] != 'l')
2625     gold_error(_("library name must be prefixed with -l"));
2626
2627   Input_file_argument file(name_string.c_str() + 1,
2628                            Input_file_argument::INPUT_FILE_TYPE_LIBRARY,
2629                            "", false,
2630                            closure->position_dependent_options());
2631   closure->inputs()->add_file(file);
2632 }
2633
2634 // Called by the bison parser to start a group.  If we are already in
2635 // a group, that means that this script was invoked within a
2636 // --start-group --end-group sequence on the command line, or that
2637 // this script was found in a GROUP of another script.  In that case,
2638 // we simply continue the existing group, rather than starting a new
2639 // one.  It is possible to construct a case in which this will do
2640 // something other than what would happen if we did a recursive group,
2641 // but it's hard to imagine why the different behaviour would be
2642 // useful for a real program.  Avoiding recursive groups is simpler
2643 // and more efficient.
2644
2645 extern "C" void
2646 script_start_group(void* closurev)
2647 {
2648   Parser_closure* closure = static_cast<Parser_closure*>(closurev);
2649   if (!closure->in_group())
2650     closure->inputs()->start_group();
2651 }
2652
2653 // Called by the bison parser at the end of a group.
2654
2655 extern "C" void
2656 script_end_group(void* closurev)
2657 {
2658   Parser_closure* closure = static_cast<Parser_closure*>(closurev);
2659   if (!closure->in_group())
2660     closure->inputs()->end_group();
2661 }
2662
2663 // Called by the bison parser to start an AS_NEEDED list.
2664
2665 extern "C" void
2666 script_start_as_needed(void* closurev)
2667 {
2668   Parser_closure* closure = static_cast<Parser_closure*>(closurev);
2669   closure->position_dependent_options().set_as_needed(true);
2670 }
2671
2672 // Called by the bison parser at the end of an AS_NEEDED list.
2673
2674 extern "C" void
2675 script_end_as_needed(void* closurev)
2676 {
2677   Parser_closure* closure = static_cast<Parser_closure*>(closurev);
2678   closure->position_dependent_options().set_as_needed(false);
2679 }
2680
2681 // Called by the bison parser to set the entry symbol.
2682
2683 extern "C" void
2684 script_set_entry(void* closurev, const char* entry, size_t length)
2685 {
2686   // We'll parse this exactly the same as --entry=ENTRY on the commandline
2687   // TODO(csilvers): FIXME -- call set_entry directly.
2688   std::string arg("--entry=");
2689   arg.append(entry, length);
2690   script_parse_option(closurev, arg.c_str(), arg.size());
2691 }
2692
2693 // Called by the bison parser to set whether to define common symbols.
2694
2695 extern "C" void
2696 script_set_common_allocation(void* closurev, int set)
2697 {
2698   const char* arg = set != 0 ? "--define-common" : "--no-define-common";
2699   script_parse_option(closurev, arg, strlen(arg));
2700 }
2701
2702 // Called by the bison parser to refer to a symbol.
2703
2704 extern "C" Expression*
2705 script_symbol(void* closurev, const char* name, size_t length)
2706 {
2707   Parser_closure* closure = static_cast<Parser_closure*>(closurev);
2708   if (length != 1 || name[0] != '.')
2709     closure->script_options()->add_symbol_reference(name, length);
2710   return script_exp_string(name, length);
2711 }
2712
2713 // Called by the bison parser to define a symbol.
2714
2715 extern "C" void
2716 script_set_symbol(void* closurev, const char* name, size_t length,
2717                   Expression* value, int providei, int hiddeni)
2718 {
2719   Parser_closure* closure = static_cast<Parser_closure*>(closurev);
2720   const bool provide = providei != 0;
2721   const bool hidden = hiddeni != 0;
2722   closure->script_options()->add_symbol_assignment(name, length,
2723                                                    closure->parsing_defsym(),
2724                                                    value, provide, hidden);
2725   closure->clear_skip_on_incompatible_target();
2726 }
2727
2728 // Called by the bison parser to add an assertion.
2729
2730 extern "C" void
2731 script_add_assertion(void* closurev, Expression* check, const char* message,
2732                      size_t messagelen)
2733 {
2734   Parser_closure* closure = static_cast<Parser_closure*>(closurev);
2735   closure->script_options()->add_assertion(check, message, messagelen);
2736   closure->clear_skip_on_incompatible_target();
2737 }
2738
2739 // Called by the bison parser to parse an OPTION.
2740
2741 extern "C" void
2742 script_parse_option(void* closurev, const char* option, size_t length)
2743 {
2744   Parser_closure* closure = static_cast<Parser_closure*>(closurev);
2745   // We treat the option as a single command-line option, even if
2746   // it has internal whitespace.
2747   if (closure->command_line() == NULL)
2748     {
2749       // There are some options that we could handle here--e.g.,
2750       // -lLIBRARY.  Should we bother?
2751       gold_warning(_("%s:%d:%d: ignoring command OPTION; OPTION is only valid"
2752                      " for scripts specified via -T/--script"),
2753                    closure->filename(), closure->lineno(), closure->charpos());
2754     }
2755   else
2756     {
2757       bool past_a_double_dash_option = false;
2758       const char* mutable_option = strndup(option, length);
2759       gold_assert(mutable_option != NULL);
2760       closure->command_line()->process_one_option(1, &mutable_option, 0,
2761                                                   &past_a_double_dash_option);
2762       // The General_options class will quite possibly store a pointer
2763       // into mutable_option, so we can't free it.  In cases the class
2764       // does not store such a pointer, this is a memory leak.  Alas. :(
2765     }
2766   closure->clear_skip_on_incompatible_target();
2767 }
2768
2769 // Called by the bison parser to handle OUTPUT_FORMAT.  OUTPUT_FORMAT
2770 // takes either one or three arguments.  In the three argument case,
2771 // the format depends on the endianness option, which we don't
2772 // currently support (FIXME).  If we see an OUTPUT_FORMAT for the
2773 // wrong format, then we want to search for a new file.  Returning 0
2774 // here will cause the parser to immediately abort.
2775
2776 extern "C" int
2777 script_check_output_format(void* closurev,
2778                            const char* default_name, size_t default_length,
2779                            const char*, size_t, const char*, size_t)
2780 {
2781   Parser_closure* closure = static_cast<Parser_closure*>(closurev);
2782   std::string name(default_name, default_length);
2783   Target* target = select_target_by_name(name.c_str());
2784   if (target == NULL || !parameters->is_compatible_target(target))
2785     {
2786       if (closure->skip_on_incompatible_target())
2787         {
2788           closure->set_found_incompatible_target();
2789           return 0;
2790         }
2791       // FIXME: Should we warn about the unknown target?
2792     }
2793   return 1;
2794 }
2795
2796 // Called by the bison parser to handle TARGET.
2797
2798 extern "C" void
2799 script_set_target(void* closurev, const char* target, size_t len)
2800 {
2801   Parser_closure* closure = static_cast<Parser_closure*>(closurev);
2802   std::string s(target, len);
2803   General_options::Object_format format_enum;
2804   format_enum = General_options::string_to_object_format(s.c_str());
2805   closure->position_dependent_options().set_format_enum(format_enum);
2806 }
2807
2808 // Called by the bison parser to handle SEARCH_DIR.  This is handled
2809 // exactly like a -L option.
2810
2811 extern "C" void
2812 script_add_search_dir(void* closurev, const char* option, size_t length)
2813 {
2814   Parser_closure* closure = static_cast<Parser_closure*>(closurev);
2815   if (closure->command_line() == NULL)
2816     gold_warning(_("%s:%d:%d: ignoring SEARCH_DIR; SEARCH_DIR is only valid"
2817                    " for scripts specified via -T/--script"),
2818                  closure->filename(), closure->lineno(), closure->charpos());
2819   else if (!closure->command_line()->options().nostdlib())
2820     {
2821       std::string s = "-L" + std::string(option, length);
2822       script_parse_option(closurev, s.c_str(), s.size());
2823     }
2824 }
2825
2826 /* Called by the bison parser to push the lexer into expression
2827    mode.  */
2828
2829 extern "C" void
2830 script_push_lex_into_expression_mode(void* closurev)
2831 {
2832   Parser_closure* closure = static_cast<Parser_closure*>(closurev);
2833   closure->push_lex_mode(Lex::EXPRESSION);
2834 }
2835
2836 /* Called by the bison parser to push the lexer into version
2837    mode.  */
2838
2839 extern "C" void
2840 script_push_lex_into_version_mode(void* closurev)
2841 {
2842   Parser_closure* closure = static_cast<Parser_closure*>(closurev);
2843   if (closure->version_script()->is_finalized())
2844     gold_error(_("%s:%d:%d: invalid use of VERSION in input file"),
2845                closure->filename(), closure->lineno(), closure->charpos());
2846   closure->push_lex_mode(Lex::VERSION_SCRIPT);
2847 }
2848
2849 /* Called by the bison parser to pop the lexer mode.  */
2850
2851 extern "C" void
2852 script_pop_lex_mode(void* closurev)
2853 {
2854   Parser_closure* closure = static_cast<Parser_closure*>(closurev);
2855   closure->pop_lex_mode();
2856 }
2857
2858 // Register an entire version node. For example:
2859 //
2860 // GLIBC_2.1 {
2861 //   global: foo;
2862 // } GLIBC_2.0;
2863 //
2864 // - tag is "GLIBC_2.1"
2865 // - tree contains the information "global: foo"
2866 // - deps contains "GLIBC_2.0"
2867
2868 extern "C" void
2869 script_register_vers_node(void*,
2870                           const char* tag,
2871                           int taglen,
2872                           struct Version_tree* tree,
2873                           struct Version_dependency_list* deps)
2874 {
2875   gold_assert(tree != NULL);
2876   tree->dependencies = deps;
2877   if (tag != NULL)
2878     tree->tag = std::string(tag, taglen);
2879 }
2880
2881 // Add a dependencies to the list of existing dependencies, if any,
2882 // and return the expanded list.
2883
2884 extern "C" struct Version_dependency_list*
2885 script_add_vers_depend(void* closurev,
2886                        struct Version_dependency_list* all_deps,
2887                        const char* depend_to_add, int deplen)
2888 {
2889   Parser_closure* closure = static_cast<Parser_closure*>(closurev);
2890   if (all_deps == NULL)
2891     all_deps = closure->version_script()->allocate_dependency_list();
2892   all_deps->dependencies.push_back(std::string(depend_to_add, deplen));
2893   return all_deps;
2894 }
2895
2896 // Add a pattern expression to an existing list of expressions, if any.
2897
2898 extern "C" struct Version_expression_list*
2899 script_new_vers_pattern(void* closurev,
2900                         struct Version_expression_list* expressions,
2901                         const char* pattern, int patlen, int exact_match)
2902 {
2903   Parser_closure* closure = static_cast<Parser_closure*>(closurev);
2904   if (expressions == NULL)
2905     expressions = closure->version_script()->allocate_expression_list();
2906   expressions->expressions.push_back(
2907       Version_expression(std::string(pattern, patlen),
2908                          closure->get_current_language(),
2909                          static_cast<bool>(exact_match)));
2910   return expressions;
2911 }
2912
2913 // Attaches b to the end of a, and clears b.  So a = a + b and b = {}.
2914
2915 extern "C" struct Version_expression_list*
2916 script_merge_expressions(struct Version_expression_list* a,
2917                          struct Version_expression_list* b)
2918 {
2919   a->expressions.insert(a->expressions.end(),
2920                         b->expressions.begin(), b->expressions.end());
2921   // We could delete b and remove it from expressions_lists_, but
2922   // that's a lot of work.  This works just as well.
2923   b->expressions.clear();
2924   return a;
2925 }
2926
2927 // Combine the global and local expressions into a a Version_tree.
2928
2929 extern "C" struct Version_tree*
2930 script_new_vers_node(void* closurev,
2931                      struct Version_expression_list* global,
2932                      struct Version_expression_list* local)
2933 {
2934   Parser_closure* closure = static_cast<Parser_closure*>(closurev);
2935   Version_tree* tree = closure->version_script()->allocate_version_tree();
2936   tree->global = global;
2937   tree->local = local;
2938   return tree;
2939 }
2940
2941 // Handle a transition in language, such as at the
2942 // start or end of 'extern "C++"'
2943
2944 extern "C" void
2945 version_script_push_lang(void* closurev, const char* lang, int langlen)
2946 {
2947   Parser_closure* closure = static_cast<Parser_closure*>(closurev);
2948   std::string language(lang, langlen);
2949   Version_script_info::Language code;
2950   if (language.empty() || language == "C")
2951     code = Version_script_info::LANGUAGE_C;
2952   else if (language == "C++")
2953     code = Version_script_info::LANGUAGE_CXX;
2954   else if (language == "Java")
2955     code = Version_script_info::LANGUAGE_JAVA;
2956   else
2957     {
2958       char* buf = new char[langlen + 100];
2959       snprintf(buf, langlen + 100,
2960                _("unrecognized version script language '%s'"),
2961                language.c_str());
2962       yyerror(closurev, buf);
2963       delete[] buf;
2964       code = Version_script_info::LANGUAGE_C;
2965     }
2966   closure->push_language(code);
2967 }
2968
2969 extern "C" void
2970 version_script_pop_lang(void* closurev)
2971 {
2972   Parser_closure* closure = static_cast<Parser_closure*>(closurev);
2973   closure->pop_language();
2974 }
2975
2976 // Called by the bison parser to start a SECTIONS clause.
2977
2978 extern "C" void
2979 script_start_sections(void* closurev)
2980 {
2981   Parser_closure* closure = static_cast<Parser_closure*>(closurev);
2982   closure->script_options()->script_sections()->start_sections();
2983   closure->clear_skip_on_incompatible_target();
2984 }
2985
2986 // Called by the bison parser to finish a SECTIONS clause.
2987
2988 extern "C" void
2989 script_finish_sections(void* closurev)
2990 {
2991   Parser_closure* closure = static_cast<Parser_closure*>(closurev);
2992   closure->script_options()->script_sections()->finish_sections();
2993 }
2994
2995 // Start processing entries for an output section.
2996
2997 extern "C" void
2998 script_start_output_section(void* closurev, const char* name, size_t namelen,
2999                             const struct Parser_output_section_header* header)
3000 {
3001   Parser_closure* closure = static_cast<Parser_closure*>(closurev);
3002   closure->script_options()->script_sections()->start_output_section(name,
3003                                                                      namelen,
3004                                                                      header);
3005 }
3006
3007 // Finish processing entries for an output section.
3008
3009 extern "C" void
3010 script_finish_output_section(void* closurev,
3011                              const struct Parser_output_section_trailer* trail)
3012 {
3013   Parser_closure* closure = static_cast<Parser_closure*>(closurev);
3014   closure->script_options()->script_sections()->finish_output_section(trail);
3015 }
3016
3017 // Add a data item (e.g., "WORD (0)") to the current output section.
3018
3019 extern "C" void
3020 script_add_data(void* closurev, int data_token, Expression* val)
3021 {
3022   Parser_closure* closure = static_cast<Parser_closure*>(closurev);
3023   int size;
3024   bool is_signed = true;
3025   switch (data_token)
3026     {
3027     case QUAD:
3028       size = 8;
3029       is_signed = false;
3030       break;
3031     case SQUAD:
3032       size = 8;
3033       break;
3034     case LONG:
3035       size = 4;
3036       break;
3037     case SHORT:
3038       size = 2;
3039       break;
3040     case BYTE:
3041       size = 1;
3042       break;
3043     default:
3044       gold_unreachable();
3045     }
3046   closure->script_options()->script_sections()->add_data(size, is_signed, val);
3047 }
3048
3049 // Add a clause setting the fill value to the current output section.
3050
3051 extern "C" void
3052 script_add_fill(void* closurev, Expression* val)
3053 {
3054   Parser_closure* closure = static_cast<Parser_closure*>(closurev);
3055   closure->script_options()->script_sections()->add_fill(val);
3056 }
3057
3058 // Add a new input section specification to the current output
3059 // section.
3060
3061 extern "C" void
3062 script_add_input_section(void* closurev,
3063                          const struct Input_section_spec* spec,
3064                          int keepi)
3065 {
3066   Parser_closure* closure = static_cast<Parser_closure*>(closurev);
3067   bool keep = keepi != 0;
3068   closure->script_options()->script_sections()->add_input_section(spec, keep);
3069 }
3070
3071 // When we see DATA_SEGMENT_ALIGN we record that following output
3072 // sections may be relro.
3073
3074 extern "C" void
3075 script_data_segment_align(void* closurev)
3076 {
3077   Parser_closure* closure = static_cast<Parser_closure*>(closurev);
3078   if (!closure->script_options()->saw_sections_clause())
3079     gold_error(_("%s:%d:%d: DATA_SEGMENT_ALIGN not in SECTIONS clause"),
3080                closure->filename(), closure->lineno(), closure->charpos());
3081   else
3082     closure->script_options()->script_sections()->data_segment_align();
3083 }
3084
3085 // When we see DATA_SEGMENT_RELRO_END we know that all output sections
3086 // since DATA_SEGMENT_ALIGN should be relro.
3087
3088 extern "C" void
3089 script_data_segment_relro_end(void* closurev)
3090 {
3091   Parser_closure* closure = static_cast<Parser_closure*>(closurev);
3092   if (!closure->script_options()->saw_sections_clause())
3093     gold_error(_("%s:%d:%d: DATA_SEGMENT_ALIGN not in SECTIONS clause"),
3094                closure->filename(), closure->lineno(), closure->charpos());
3095   else
3096     closure->script_options()->script_sections()->data_segment_relro_end();
3097 }
3098
3099 // Create a new list of string/sort pairs.
3100
3101 extern "C" String_sort_list_ptr
3102 script_new_string_sort_list(const struct Wildcard_section* string_sort)
3103 {
3104   return new String_sort_list(1, *string_sort);
3105 }
3106
3107 // Add an entry to a list of string/sort pairs.  The way the parser
3108 // works permits us to simply modify the first parameter, rather than
3109 // copy the vector.
3110
3111 extern "C" String_sort_list_ptr
3112 script_string_sort_list_add(String_sort_list_ptr pv,
3113                             const struct Wildcard_section* string_sort)
3114 {
3115   if (pv == NULL)
3116     return script_new_string_sort_list(string_sort);
3117   else
3118     {
3119       pv->push_back(*string_sort);
3120       return pv;
3121     }
3122 }
3123
3124 // Create a new list of strings.
3125
3126 extern "C" String_list_ptr
3127 script_new_string_list(const char* str, size_t len)
3128 {
3129   return new String_list(1, std::string(str, len));
3130 }
3131
3132 // Add an element to a list of strings.  The way the parser works
3133 // permits us to simply modify the first parameter, rather than copy
3134 // the vector.
3135
3136 extern "C" String_list_ptr
3137 script_string_list_push_back(String_list_ptr pv, const char* str, size_t len)
3138 {
3139   if (pv == NULL)
3140     return script_new_string_list(str, len);
3141   else
3142     {
3143       pv->push_back(std::string(str, len));
3144       return pv;
3145     }
3146 }
3147
3148 // Concatenate two string lists.  Either or both may be NULL.  The way
3149 // the parser works permits us to modify the parameters, rather than
3150 // copy the vector.
3151
3152 extern "C" String_list_ptr
3153 script_string_list_append(String_list_ptr pv1, String_list_ptr pv2)
3154 {
3155   if (pv1 == NULL)
3156     return pv2;
3157   if (pv2 == NULL)
3158     return pv1;
3159   pv1->insert(pv1->end(), pv2->begin(), pv2->end());
3160   return pv1;
3161 }
3162
3163 // Add a new program header.
3164
3165 extern "C" void
3166 script_add_phdr(void* closurev, const char* name, size_t namelen,
3167                 unsigned int type, const Phdr_info* info)
3168 {
3169   Parser_closure* closure = static_cast<Parser_closure*>(closurev);
3170   bool includes_filehdr = info->includes_filehdr != 0;
3171   bool includes_phdrs = info->includes_phdrs != 0;
3172   bool is_flags_valid = info->is_flags_valid != 0;
3173   Script_sections* ss = closure->script_options()->script_sections();
3174   ss->add_phdr(name, namelen, type, includes_filehdr, includes_phdrs,
3175                is_flags_valid, info->flags, info->load_address);
3176   closure->clear_skip_on_incompatible_target();
3177 }
3178
3179 // Convert a program header string to a type.
3180
3181 #define PHDR_TYPE(NAME) { #NAME, sizeof(#NAME) - 1, elfcpp::NAME }
3182
3183 static struct
3184 {
3185   const char* name;
3186   size_t namelen;
3187   unsigned int val;
3188 } phdr_type_names[] =
3189 {
3190   PHDR_TYPE(PT_NULL),
3191   PHDR_TYPE(PT_LOAD),
3192   PHDR_TYPE(PT_DYNAMIC),
3193   PHDR_TYPE(PT_INTERP),
3194   PHDR_TYPE(PT_NOTE),
3195   PHDR_TYPE(PT_SHLIB),
3196   PHDR_TYPE(PT_PHDR),
3197   PHDR_TYPE(PT_TLS),
3198   PHDR_TYPE(PT_GNU_EH_FRAME),
3199   PHDR_TYPE(PT_GNU_STACK),
3200   PHDR_TYPE(PT_GNU_RELRO)
3201 };
3202
3203 extern "C" unsigned int
3204 script_phdr_string_to_type(void* closurev, const char* name, size_t namelen)
3205 {
3206   for (unsigned int i = 0;
3207        i < sizeof(phdr_type_names) / sizeof(phdr_type_names[0]);
3208        ++i)
3209     if (namelen == phdr_type_names[i].namelen
3210         && strncmp(name, phdr_type_names[i].name, namelen) == 0)
3211       return phdr_type_names[i].val;
3212   yyerror(closurev, _("unknown PHDR type (try integer)"));
3213   return elfcpp::PT_NULL;
3214 }
3215
3216 extern "C" void
3217 script_saw_segment_start_expression(void* closurev)
3218 {
3219   Parser_closure* closure = static_cast<Parser_closure*>(closurev);
3220   Script_sections* ss = closure->script_options()->script_sections();
3221   ss->set_saw_segment_start_expression(true);
3222 }
3223
3224 extern "C" void
3225 script_set_section_region(void* closurev, const char* name, size_t namelen,
3226                           int set_vma)
3227 {
3228   Parser_closure* closure = static_cast<Parser_closure*>(closurev);
3229   if (!closure->script_options()->saw_sections_clause())
3230     {
3231       gold_error(_("%s:%d:%d: MEMORY region '%.*s' referred to outside of "
3232                    "SECTIONS clause"),
3233                  closure->filename(), closure->lineno(), closure->charpos(),
3234                  namelen, name);
3235       return;
3236     }
3237
3238   Script_sections* ss = closure->script_options()->script_sections();
3239   Memory_region* mr = ss->find_memory_region(name, namelen);
3240   if (mr == NULL)
3241     {
3242       gold_error(_("%s:%d:%d: MEMORY region '%.*s' not declared"),
3243                  closure->filename(), closure->lineno(), closure->charpos(),
3244                  namelen, name);
3245       return;
3246     }
3247
3248   ss->set_memory_region(mr, set_vma);
3249 }
3250
3251 extern "C" void
3252 script_add_memory(void* closurev, const char* name, size_t namelen,
3253                   unsigned int attrs, Expression* origin, Expression* length)
3254 {
3255   Parser_closure* closure = static_cast<Parser_closure*>(closurev);
3256   Script_sections* ss = closure->script_options()->script_sections();
3257   ss->add_memory_region(name, namelen, attrs, origin, length);
3258 }
3259
3260 extern "C" unsigned int
3261 script_parse_memory_attr(void* closurev, const char* attrs, size_t attrlen,
3262                          int invert)
3263 {
3264   int attributes = 0;
3265
3266   while (attrlen--)
3267     switch (*attrs++)
3268       {
3269       case 'R':
3270       case 'r':
3271         attributes |= MEM_READABLE; break;
3272       case 'W':
3273       case 'w':
3274         attributes |= MEM_READABLE | MEM_WRITEABLE; break;
3275       case 'X':
3276       case 'x':
3277         attributes |= MEM_EXECUTABLE; break;
3278       case 'A':
3279       case 'a':
3280         attributes |= MEM_ALLOCATABLE; break;
3281       case 'I':
3282       case 'i':
3283       case 'L':
3284       case 'l':
3285         attributes |= MEM_INITIALIZED; break;
3286       default:
3287         yyerror(closurev, _("unknown MEMORY attribute"));
3288       }
3289
3290   if (invert)
3291     attributes = (~ attributes) & MEM_ATTR_MASK;
3292
3293   return attributes;
3294 }
3295
3296 extern "C" void
3297 script_include_directive(void* closurev, const char*, size_t)
3298 {
3299   // FIXME: Implement ?
3300   yyerror (closurev, _("GOLD does not currently support INCLUDE directives"));
3301 }
3302
3303 // Functions for memory regions.
3304
3305 extern "C" Expression*
3306 script_exp_function_origin(void* closurev, const char* name, size_t namelen)
3307 {
3308   Parser_closure* closure = static_cast<Parser_closure*>(closurev);
3309   Script_sections* ss = closure->script_options()->script_sections();
3310   Expression* origin = ss->find_memory_region_origin(name, namelen);
3311
3312   if (origin == NULL)
3313     {
3314       gold_error(_("undefined memory region '%s' referenced "
3315                    "in ORIGIN expression"),
3316                  name);
3317       // Create a dummy expression to prevent crashes later on.
3318       origin = script_exp_integer(0);
3319     }
3320
3321   return origin;
3322 }
3323
3324 extern "C" Expression*
3325 script_exp_function_length(void* closurev, const char* name, size_t namelen)
3326 {
3327   Parser_closure* closure = static_cast<Parser_closure*>(closurev);
3328   Script_sections* ss = closure->script_options()->script_sections();
3329   Expression* length = ss->find_memory_region_length(name, namelen);
3330
3331   if (length == NULL)
3332     {
3333       gold_error(_("undefined memory region '%s' referenced "
3334                    "in LENGTH expression"),
3335                  name);
3336       // Create a dummy expression to prevent crashes later on.
3337       length = script_exp_integer(0);
3338     }
3339
3340   return length;
3341 }