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