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