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