1 // expression.cc -- expressions in linker scripts for gold 2 3 // Copyright (C) 2006-2016 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 <string> 26 27 #include "elfcpp.h" 28 #include "parameters.h" 29 #include "symtab.h" 30 #include "layout.h" 31 #include "output.h" 32 #include "script.h" 33 #include "script-c.h" 34 35 namespace gold 36 { 37 38 // This file holds the code which handles linker expressions. 39 40 // The dot symbol, which linker scripts refer to simply as ".", 41 // requires special treatment. The dot symbol is set several times, 42 // section addresses will refer to it, output sections will change it, 43 // and it can be set based on the value of other symbols. We simplify 44 // the handling by prohibiting setting the dot symbol to the value of 45 // a non-absolute symbol. 46 47 // When evaluating the value of an expression, we pass in a pointer to 48 // this struct, so that the expression evaluation can find the 49 // information it needs. 50 51 struct Expression::Expression_eval_info 52 { 53 // The symbol table. 54 const Symbol_table* symtab; 55 // The layout--we use this to get section information. 56 const Layout* layout; 57 // Whether to check assertions. 58 bool check_assertions; 59 // Whether expressions can refer to the dot symbol. The dot symbol 60 // is only available within a SECTIONS clause. 61 bool is_dot_available; 62 // The current value of the dot symbol. 63 uint64_t dot_value; 64 // The section in which the dot symbol is defined; this is NULL if 65 // it is absolute. 66 Output_section* dot_section; 67 // Points to where the section of the result should be stored. 68 Output_section** result_section_pointer; 69 // Pointer to where the alignment of the result should be stored. 70 uint64_t* result_alignment_pointer; 71 // Pointer to where the type of the symbol on the RHS should be stored. 72 elfcpp::STT* type_pointer; 73 // Pointer to where the visibility of the symbol on the RHS should be stored. 74 elfcpp::STV* vis_pointer; 75 // Pointer to where the rest of the symbol's st_other field should be stored. 76 unsigned char* nonvis_pointer; 77 // Whether the value is valid. In Symbol_assignment::set_if_absolute, we 78 // may be trying to evaluate the address of a section whose address is not 79 // yet finalized, and we need to fail the evaluation gracefully. 80 bool *is_valid_pointer; 81 }; 82 83 // Evaluate an expression. 84 85 uint64_t 86 Expression::eval(const Symbol_table* symtab, const Layout* layout, 87 bool check_assertions) 88 { 89 return this->eval_maybe_dot(symtab, layout, check_assertions, false, 0, 90 NULL, NULL, NULL, NULL, NULL, NULL, false, NULL); 91 } 92 93 // Evaluate an expression which may refer to the dot symbol. 94 95 uint64_t 96 Expression::eval_with_dot(const Symbol_table* symtab, const Layout* layout, 97 bool check_assertions, uint64_t dot_value, 98 Output_section* dot_section, 99 Output_section** result_section_pointer, 100 uint64_t* result_alignment_pointer, 101 bool is_section_dot_assignment) 102 { 103 return this->eval_maybe_dot(symtab, layout, check_assertions, true, 104 dot_value, dot_section, result_section_pointer, 105 result_alignment_pointer, NULL, NULL, NULL, 106 is_section_dot_assignment, NULL); 107 } 108 109 // Evaluate an expression which may or may not refer to the dot 110 // symbol. 111 112 uint64_t 113 Expression::eval_maybe_dot(const Symbol_table* symtab, const Layout* layout, 114 bool check_assertions, bool is_dot_available, 115 uint64_t dot_value, Output_section* dot_section, 116 Output_section** result_section_pointer, 117 uint64_t* result_alignment_pointer, 118 elfcpp::STT* type_pointer, 119 elfcpp::STV* vis_pointer, 120 unsigned char* nonvis_pointer, 121 bool is_section_dot_assignment, 122 bool* is_valid_pointer) 123 { 124 Expression_eval_info eei; 125 eei.symtab = symtab; 126 eei.layout = layout; 127 eei.check_assertions = check_assertions; 128 eei.is_dot_available = is_dot_available; 129 eei.dot_value = dot_value; 130 eei.dot_section = dot_section; 131 132 // We assume the value is absolute, and only set this to a section 133 // if we find a section-relative reference. 134 if (result_section_pointer != NULL) 135 *result_section_pointer = NULL; 136 eei.result_section_pointer = result_section_pointer; 137 138 // For symbol=symbol assignments, we need to track the type, visibility, 139 // and remaining st_other bits. 140 eei.type_pointer = type_pointer; 141 eei.vis_pointer = vis_pointer; 142 eei.nonvis_pointer = nonvis_pointer; 143 144 eei.result_alignment_pointer = result_alignment_pointer; 145 146 // Assume the value is valid until we try to evaluate an expression 147 // that can't be evaluated yet. 148 bool is_valid = true; 149 eei.is_valid_pointer = &is_valid; 150 151 uint64_t val = this->value(&eei); 152 153 if (is_valid_pointer != NULL) 154 *is_valid_pointer = is_valid; 155 else 156 gold_assert(is_valid); 157 158 // If this is an assignment to dot within a section, and the value 159 // is absolute, treat it as a section-relative offset. 160 if (is_section_dot_assignment && *result_section_pointer == NULL) 161 { 162 gold_assert(dot_section != NULL); 163 val += dot_section->address(); 164 *result_section_pointer = dot_section; 165 } 166 return val; 167 } 168 169 // A number. 170 171 class Integer_expression : public Expression 172 { 173 public: 174 Integer_expression(uint64_t val) 175 : val_(val) 176 { } 177 178 uint64_t 179 value(const Expression_eval_info*) 180 { return this->val_; } 181 182 void 183 print(FILE* f) const 184 { fprintf(f, "0x%llx", static_cast<unsigned long long>(this->val_)); } 185 186 private: 187 uint64_t val_; 188 }; 189 190 extern "C" Expression* 191 script_exp_integer(uint64_t val) 192 { 193 return new Integer_expression(val); 194 } 195 196 // An expression whose value is the value of a symbol. 197 198 class Symbol_expression : public Expression 199 { 200 public: 201 Symbol_expression(const char* name, size_t length) 202 : name_(name, length) 203 { } 204 205 uint64_t 206 value(const Expression_eval_info*); 207 208 void 209 print(FILE* f) const 210 { fprintf(f, "%s", this->name_.c_str()); } 211 212 private: 213 std::string name_; 214 }; 215 216 uint64_t 217 Symbol_expression::value(const Expression_eval_info* eei) 218 { 219 Symbol* sym = eei->symtab->lookup(this->name_.c_str()); 220 if (sym == NULL || !sym->is_defined()) 221 { 222 gold_error(_("undefined symbol '%s' referenced in expression"), 223 this->name_.c_str()); 224 return 0; 225 } 226 227 if (eei->result_section_pointer != NULL) 228 *eei->result_section_pointer = sym->output_section(); 229 if (eei->type_pointer != NULL) 230 *eei->type_pointer = sym->type(); 231 if (eei->vis_pointer != NULL) 232 *eei->vis_pointer = sym->visibility(); 233 if (eei->nonvis_pointer != NULL) 234 *eei->nonvis_pointer = sym->nonvis(); 235 236 if (parameters->target().get_size() == 32) 237 return eei->symtab->get_sized_symbol<32>(sym)->value(); 238 else if (parameters->target().get_size() == 64) 239 return eei->symtab->get_sized_symbol<64>(sym)->value(); 240 else 241 gold_unreachable(); 242 } 243 244 // An expression whose value is the value of the special symbol ".". 245 // This is only valid within a SECTIONS clause. 246 247 class Dot_expression : public Expression 248 { 249 public: 250 Dot_expression() 251 { } 252 253 uint64_t 254 value(const Expression_eval_info*); 255 256 void 257 print(FILE* f) const 258 { fprintf(f, "."); } 259 }; 260 261 uint64_t 262 Dot_expression::value(const Expression_eval_info* eei) 263 { 264 if (!eei->is_dot_available) 265 { 266 gold_error(_("invalid reference to dot symbol outside of " 267 "SECTIONS clause")); 268 return 0; 269 } 270 if (eei->result_section_pointer != NULL) 271 *eei->result_section_pointer = eei->dot_section; 272 return eei->dot_value; 273 } 274 275 // A string. This is either the name of a symbol, or ".". 276 277 extern "C" Expression* 278 script_exp_string(const char* name, size_t length) 279 { 280 if (length == 1 && name[0] == '.') 281 return new Dot_expression(); 282 else 283 return new Symbol_expression(name, length); 284 } 285 286 // A unary expression. 287 288 class Unary_expression : public Expression 289 { 290 public: 291 Unary_expression(Expression* arg) 292 : arg_(arg) 293 { } 294 295 ~Unary_expression() 296 { delete this->arg_; } 297 298 protected: 299 uint64_t 300 arg_value(const Expression_eval_info* eei, 301 Output_section** arg_section_pointer) const 302 { 303 return this->arg_->eval_maybe_dot(eei->symtab, eei->layout, 304 eei->check_assertions, 305 eei->is_dot_available, 306 eei->dot_value, 307 eei->dot_section, 308 arg_section_pointer, 309 eei->result_alignment_pointer, 310 NULL, 311 NULL, 312 NULL, 313 false, 314 eei->is_valid_pointer); 315 } 316 317 void 318 arg_print(FILE* f) const 319 { this->arg_->print(f); } 320 321 private: 322 Expression* arg_; 323 }; 324 325 // Handle unary operators. We use a preprocessor macro as a hack to 326 // capture the C operator. 327 328 #define UNARY_EXPRESSION(NAME, OPERATOR) \ 329 class Unary_ ## NAME : public Unary_expression \ 330 { \ 331 public: \ 332 Unary_ ## NAME(Expression* arg) \ 333 : Unary_expression(arg) \ 334 { } \ 335 \ 336 uint64_t \ 337 value(const Expression_eval_info* eei) \ 338 { \ 339 Output_section* arg_section; \ 340 uint64_t ret = OPERATOR this->arg_value(eei, &arg_section); \ 341 if (arg_section != NULL && parameters->options().relocatable()) \ 342 gold_warning(_("unary " #NAME " applied to section " \ 343 "relative value")); \ 344 return ret; \ 345 } \ 346 \ 347 void \ 348 print(FILE* f) const \ 349 { \ 350 fprintf(f, "(%s ", #OPERATOR); \ 351 this->arg_print(f); \ 352 fprintf(f, ")"); \ 353 } \ 354 }; \ 355 \ 356 extern "C" Expression* \ 357 script_exp_unary_ ## NAME(Expression* arg) \ 358 { \ 359 return new Unary_ ## NAME(arg); \ 360 } 361 362 UNARY_EXPRESSION(minus, -) 363 UNARY_EXPRESSION(logical_not, !) 364 UNARY_EXPRESSION(bitwise_not, ~) 365 366 // A binary expression. 367 368 class Binary_expression : public Expression 369 { 370 public: 371 Binary_expression(Expression* left, Expression* right) 372 : left_(left), right_(right) 373 { } 374 375 ~Binary_expression() 376 { 377 delete this->left_; 378 delete this->right_; 379 } 380 381 protected: 382 uint64_t 383 left_value(const Expression_eval_info* eei, 384 Output_section** section_pointer, 385 uint64_t* alignment_pointer) const 386 { 387 return this->left_->eval_maybe_dot(eei->symtab, eei->layout, 388 eei->check_assertions, 389 eei->is_dot_available, 390 eei->dot_value, 391 eei->dot_section, 392 section_pointer, 393 alignment_pointer, 394 NULL, 395 NULL, 396 NULL, 397 false, 398 eei->is_valid_pointer); 399 } 400 401 uint64_t 402 right_value(const Expression_eval_info* eei, 403 Output_section** section_pointer, 404 uint64_t* alignment_pointer) const 405 { 406 return this->right_->eval_maybe_dot(eei->symtab, eei->layout, 407 eei->check_assertions, 408 eei->is_dot_available, 409 eei->dot_value, 410 eei->dot_section, 411 section_pointer, 412 alignment_pointer, 413 NULL, 414 NULL, 415 NULL, 416 false, 417 eei->is_valid_pointer); 418 } 419 420 void 421 left_print(FILE* f) const 422 { this->left_->print(f); } 423 424 void 425 right_print(FILE* f) const 426 { this->right_->print(f); } 427 428 // This is a call to function FUNCTION_NAME. Print it. This is for 429 // debugging. 430 void 431 print_function(FILE* f, const char* function_name) const 432 { 433 fprintf(f, "%s(", function_name); 434 this->left_print(f); 435 fprintf(f, ", "); 436 this->right_print(f); 437 fprintf(f, ")"); 438 } 439 440 private: 441 Expression* left_; 442 Expression* right_; 443 }; 444 445 // Handle binary operators. We use a preprocessor macro as a hack to 446 // capture the C operator. KEEP_LEFT means that if the left operand 447 // is section relative and the right operand is not, the result uses 448 // the same section as the left operand. KEEP_RIGHT is the same with 449 // left and right swapped. IS_DIV means that we need to give an error 450 // if the right operand is zero. WARN means that we should warn if 451 // used on section relative values in a relocatable link. We always 452 // warn if used on values in different sections in a relocatable link. 453 454 #define BINARY_EXPRESSION(NAME, OPERATOR, KEEP_LEFT, KEEP_RIGHT, IS_DIV, WARN) \ 455 class Binary_ ## NAME : public Binary_expression \ 456 { \ 457 public: \ 458 Binary_ ## NAME(Expression* left, Expression* right) \ 459 : Binary_expression(left, right) \ 460 { } \ 461 \ 462 uint64_t \ 463 value(const Expression_eval_info* eei) \ 464 { \ 465 Output_section* left_section; \ 466 uint64_t left_alignment = 0; \ 467 uint64_t left = this->left_value(eei, &left_section, \ 468 &left_alignment); \ 469 Output_section* right_section; \ 470 uint64_t right_alignment = 0; \ 471 uint64_t right = this->right_value(eei, &right_section, \ 472 &right_alignment); \ 473 if (KEEP_RIGHT && left_section == NULL && right_section != NULL) \ 474 { \ 475 if (eei->result_section_pointer != NULL) \ 476 *eei->result_section_pointer = right_section; \ 477 if (eei->result_alignment_pointer != NULL \ 478 && right_alignment > *eei->result_alignment_pointer) \ 479 *eei->result_alignment_pointer = right_alignment; \ 480 } \ 481 else if (KEEP_LEFT \ 482 && left_section != NULL \ 483 && right_section == NULL) \ 484 { \ 485 if (eei->result_section_pointer != NULL) \ 486 *eei->result_section_pointer = left_section; \ 487 if (eei->result_alignment_pointer != NULL \ 488 && left_alignment > *eei->result_alignment_pointer) \ 489 *eei->result_alignment_pointer = left_alignment; \ 490 } \ 491 else if ((WARN || left_section != right_section) \ 492 && (left_section != NULL || right_section != NULL) \ 493 && parameters->options().relocatable()) \ 494 gold_warning(_("binary " #NAME " applied to section " \ 495 "relative value")); \ 496 if (IS_DIV && right == 0) \ 497 { \ 498 gold_error(_(#NAME " by zero")); \ 499 return 0; \ 500 } \ 501 return left OPERATOR right; \ 502 } \ 503 \ 504 void \ 505 print(FILE* f) const \ 506 { \ 507 fprintf(f, "("); \ 508 this->left_print(f); \ 509 fprintf(f, " %s ", #OPERATOR); \ 510 this->right_print(f); \ 511 fprintf(f, ")"); \ 512 } \ 513 }; \ 514 \ 515 extern "C" Expression* \ 516 script_exp_binary_ ## NAME(Expression* left, Expression* right) \ 517 { \ 518 return new Binary_ ## NAME(left, right); \ 519 } 520 521 BINARY_EXPRESSION(mult, *, false, false, false, true) 522 BINARY_EXPRESSION(div, /, false, false, true, true) 523 BINARY_EXPRESSION(mod, %, false, false, true, true) 524 BINARY_EXPRESSION(add, +, true, true, false, true) 525 BINARY_EXPRESSION(sub, -, true, false, false, false) 526 BINARY_EXPRESSION(lshift, <<, false, false, false, true) 527 BINARY_EXPRESSION(rshift, >>, false, false, false, true) 528 BINARY_EXPRESSION(eq, ==, false, false, false, false) 529 BINARY_EXPRESSION(ne, !=, false, false, false, false) 530 BINARY_EXPRESSION(le, <=, false, false, false, false) 531 BINARY_EXPRESSION(ge, >=, false, false, false, false) 532 BINARY_EXPRESSION(lt, <, false, false, false, false) 533 BINARY_EXPRESSION(gt, >, false, false, false, false) 534 BINARY_EXPRESSION(bitwise_and, &, true, true, false, true) 535 BINARY_EXPRESSION(bitwise_xor, ^, true, true, false, true) 536 BINARY_EXPRESSION(bitwise_or, |, true, true, false, true) 537 BINARY_EXPRESSION(logical_and, &&, false, false, false, true) 538 BINARY_EXPRESSION(logical_or, ||, false, false, false, true) 539 540 // A trinary expression. 541 542 class Trinary_expression : public Expression 543 { 544 public: 545 Trinary_expression(Expression* arg1, Expression* arg2, Expression* arg3) 546 : arg1_(arg1), arg2_(arg2), arg3_(arg3) 547 { } 548 549 ~Trinary_expression() 550 { 551 delete this->arg1_; 552 delete this->arg2_; 553 delete this->arg3_; 554 } 555 556 protected: 557 uint64_t 558 arg1_value(const Expression_eval_info* eei, 559 Output_section** section_pointer) const 560 { 561 return this->arg1_->eval_maybe_dot(eei->symtab, eei->layout, 562 eei->check_assertions, 563 eei->is_dot_available, 564 eei->dot_value, 565 eei->dot_section, 566 section_pointer, 567 NULL, 568 NULL, 569 NULL, 570 NULL, 571 false, 572 eei->is_valid_pointer); 573 } 574 575 uint64_t 576 arg2_value(const Expression_eval_info* eei, 577 Output_section** section_pointer, 578 uint64_t* alignment_pointer) const 579 { 580 return this->arg1_->eval_maybe_dot(eei->symtab, eei->layout, 581 eei->check_assertions, 582 eei->is_dot_available, 583 eei->dot_value, 584 eei->dot_section, 585 section_pointer, 586 alignment_pointer, 587 NULL, 588 NULL, 589 NULL, 590 false, 591 eei->is_valid_pointer); 592 } 593 594 uint64_t 595 arg3_value(const Expression_eval_info* eei, 596 Output_section** section_pointer, 597 uint64_t* alignment_pointer) const 598 { 599 return this->arg1_->eval_maybe_dot(eei->symtab, eei->layout, 600 eei->check_assertions, 601 eei->is_dot_available, 602 eei->dot_value, 603 eei->dot_section, 604 section_pointer, 605 alignment_pointer, 606 NULL, 607 NULL, 608 NULL, 609 false, 610 eei->is_valid_pointer); 611 } 612 613 void 614 arg1_print(FILE* f) const 615 { this->arg1_->print(f); } 616 617 void 618 arg2_print(FILE* f) const 619 { this->arg2_->print(f); } 620 621 void 622 arg3_print(FILE* f) const 623 { this->arg3_->print(f); } 624 625 private: 626 Expression* arg1_; 627 Expression* arg2_; 628 Expression* arg3_; 629 }; 630 631 // The conditional operator. 632 633 class Trinary_cond : public Trinary_expression 634 { 635 public: 636 Trinary_cond(Expression* arg1, Expression* arg2, Expression* arg3) 637 : Trinary_expression(arg1, arg2, arg3) 638 { } 639 640 uint64_t 641 value(const Expression_eval_info* eei) 642 { 643 Output_section* arg1_section; 644 uint64_t arg1 = this->arg1_value(eei, &arg1_section); 645 return (arg1 646 ? this->arg2_value(eei, eei->result_section_pointer, 647 eei->result_alignment_pointer) 648 : this->arg3_value(eei, eei->result_section_pointer, 649 eei->result_alignment_pointer)); 650 } 651 652 void 653 print(FILE* f) const 654 { 655 fprintf(f, "("); 656 this->arg1_print(f); 657 fprintf(f, " ? "); 658 this->arg2_print(f); 659 fprintf(f, " : "); 660 this->arg3_print(f); 661 fprintf(f, ")"); 662 } 663 }; 664 665 extern "C" Expression* 666 script_exp_trinary_cond(Expression* arg1, Expression* arg2, Expression* arg3) 667 { 668 return new Trinary_cond(arg1, arg2, arg3); 669 } 670 671 // Max function. 672 673 class Max_expression : public Binary_expression 674 { 675 public: 676 Max_expression(Expression* left, Expression* right) 677 : Binary_expression(left, right) 678 { } 679 680 uint64_t 681 value(const Expression_eval_info* eei) 682 { 683 Output_section* left_section; 684 uint64_t left_alignment; 685 uint64_t left = this->left_value(eei, &left_section, &left_alignment); 686 Output_section* right_section; 687 uint64_t right_alignment; 688 uint64_t right = this->right_value(eei, &right_section, &right_alignment); 689 if (left_section == right_section) 690 { 691 if (eei->result_section_pointer != NULL) 692 *eei->result_section_pointer = left_section; 693 } 694 else if ((left_section != NULL || right_section != NULL) 695 && parameters->options().relocatable()) 696 gold_warning(_("max applied to section relative value")); 697 if (eei->result_alignment_pointer != NULL) 698 { 699 uint64_t ra = *eei->result_alignment_pointer; 700 if (left > right) 701 ra = std::max(ra, left_alignment); 702 else if (right > left) 703 ra = std::max(ra, right_alignment); 704 else 705 ra = std::max(ra, std::max(left_alignment, right_alignment)); 706 *eei->result_alignment_pointer = ra; 707 } 708 return std::max(left, right); 709 } 710 711 void 712 print(FILE* f) const 713 { this->print_function(f, "MAX"); } 714 }; 715 716 extern "C" Expression* 717 script_exp_function_max(Expression* left, Expression* right) 718 { 719 return new Max_expression(left, right); 720 } 721 722 // Min function. 723 724 class Min_expression : public Binary_expression 725 { 726 public: 727 Min_expression(Expression* left, Expression* right) 728 : Binary_expression(left, right) 729 { } 730 731 uint64_t 732 value(const Expression_eval_info* eei) 733 { 734 Output_section* left_section; 735 uint64_t left_alignment; 736 uint64_t left = this->left_value(eei, &left_section, &left_alignment); 737 Output_section* right_section; 738 uint64_t right_alignment; 739 uint64_t right = this->right_value(eei, &right_section, &right_alignment); 740 if (left_section == right_section) 741 { 742 if (eei->result_section_pointer != NULL) 743 *eei->result_section_pointer = left_section; 744 } 745 else if ((left_section != NULL || right_section != NULL) 746 && parameters->options().relocatable()) 747 gold_warning(_("min applied to section relative value")); 748 if (eei->result_alignment_pointer != NULL) 749 { 750 uint64_t ra = *eei->result_alignment_pointer; 751 if (left < right) 752 ra = std::max(ra, left_alignment); 753 else if (right < left) 754 ra = std::max(ra, right_alignment); 755 else 756 ra = std::max(ra, std::max(left_alignment, right_alignment)); 757 *eei->result_alignment_pointer = ra; 758 } 759 return std::min(left, right); 760 } 761 762 void 763 print(FILE* f) const 764 { this->print_function(f, "MIN"); } 765 }; 766 767 extern "C" Expression* 768 script_exp_function_min(Expression* left, Expression* right) 769 { 770 return new Min_expression(left, right); 771 } 772 773 // Class Section_expression. This is a parent class used for 774 // functions which take the name of an output section. 775 776 class Section_expression : public Expression 777 { 778 public: 779 Section_expression(const char* section_name, size_t section_name_len) 780 : section_name_(section_name, section_name_len) 781 { } 782 783 uint64_t 784 value(const Expression_eval_info*); 785 786 void 787 print(FILE* f) const 788 { fprintf(f, "%s(%s)", this->function_name(), this->section_name_.c_str()); } 789 790 protected: 791 // The child class must implement this. 792 virtual uint64_t 793 value_from_output_section(const Expression_eval_info*, 794 Output_section*) = 0; 795 796 // The child class must implement this. 797 virtual uint64_t 798 value_from_script_output_section(uint64_t address, uint64_t load_address, 799 uint64_t addralign, uint64_t size) = 0; 800 801 // The child class must implement this. 802 virtual const char* 803 function_name() const = 0; 804 805 private: 806 std::string section_name_; 807 }; 808 809 uint64_t 810 Section_expression::value(const Expression_eval_info* eei) 811 { 812 const char* section_name = this->section_name_.c_str(); 813 Output_section* os = eei->layout->find_output_section(section_name); 814 if (os != NULL) 815 return this->value_from_output_section(eei, os); 816 817 uint64_t address; 818 uint64_t load_address; 819 uint64_t addralign; 820 uint64_t size; 821 const Script_options* ss = eei->layout->script_options(); 822 if (ss->saw_sections_clause()) 823 { 824 if (ss->script_sections()->get_output_section_info(section_name, 825 &address, 826 &load_address, 827 &addralign, 828 &size)) 829 return this->value_from_script_output_section(address, load_address, 830 addralign, size); 831 } 832 833 gold_error("%s called on nonexistent output section '%s'", 834 this->function_name(), section_name); 835 return 0; 836 } 837 838 // ABSOLUTE function. 839 840 class Absolute_expression : public Unary_expression 841 { 842 public: 843 Absolute_expression(Expression* arg) 844 : Unary_expression(arg) 845 { } 846 847 uint64_t 848 value(const Expression_eval_info* eei) 849 { 850 uint64_t ret = this->arg_value(eei, NULL); 851 // Force the value to be absolute. 852 if (eei->result_section_pointer != NULL) 853 *eei->result_section_pointer = NULL; 854 return ret; 855 } 856 857 void 858 print(FILE* f) const 859 { 860 fprintf(f, "ABSOLUTE("); 861 this->arg_print(f); 862 fprintf(f, ")"); 863 } 864 }; 865 866 extern "C" Expression* 867 script_exp_function_absolute(Expression* arg) 868 { 869 return new Absolute_expression(arg); 870 } 871 872 // ALIGN function. 873 874 class Align_expression : public Binary_expression 875 { 876 public: 877 Align_expression(Expression* left, Expression* right) 878 : Binary_expression(left, right) 879 { } 880 881 uint64_t 882 value(const Expression_eval_info* eei) 883 { 884 Output_section* align_section; 885 uint64_t align = this->right_value(eei, &align_section, NULL); 886 if (align_section != NULL 887 && parameters->options().relocatable()) 888 gold_warning(_("aligning to section relative value")); 889 890 if (eei->result_alignment_pointer != NULL 891 && align > *eei->result_alignment_pointer) 892 { 893 uint64_t a = align; 894 while ((a & (a - 1)) != 0) 895 a &= a - 1; 896 *eei->result_alignment_pointer = a; 897 } 898 899 uint64_t value = this->left_value(eei, eei->result_section_pointer, NULL); 900 if (align <= 1) 901 return value; 902 return ((value + align - 1) / align) * align; 903 } 904 905 void 906 print(FILE* f) const 907 { this->print_function(f, "ALIGN"); } 908 }; 909 910 extern "C" Expression* 911 script_exp_function_align(Expression* left, Expression* right) 912 { 913 return new Align_expression(left, right); 914 } 915 916 // ASSERT function. 917 918 class Assert_expression : public Unary_expression 919 { 920 public: 921 Assert_expression(Expression* arg, const char* message, size_t length) 922 : Unary_expression(arg), message_(message, length) 923 { } 924 925 uint64_t 926 value(const Expression_eval_info* eei) 927 { 928 uint64_t value = this->arg_value(eei, eei->result_section_pointer); 929 if (!value && eei->check_assertions) 930 gold_error("%s", this->message_.c_str()); 931 return value; 932 } 933 934 void 935 print(FILE* f) const 936 { 937 fprintf(f, "ASSERT("); 938 this->arg_print(f); 939 fprintf(f, ", %s)", this->message_.c_str()); 940 } 941 942 private: 943 std::string message_; 944 }; 945 946 extern "C" Expression* 947 script_exp_function_assert(Expression* expr, const char* message, 948 size_t length) 949 { 950 return new Assert_expression(expr, message, length); 951 } 952 953 // ADDR function. 954 955 class Addr_expression : public Section_expression 956 { 957 public: 958 Addr_expression(const char* section_name, size_t section_name_len) 959 : Section_expression(section_name, section_name_len) 960 { } 961 962 protected: 963 uint64_t 964 value_from_output_section(const Expression_eval_info* eei, 965 Output_section* os) 966 { 967 if (eei->result_section_pointer != NULL) 968 *eei->result_section_pointer = os; 969 if (os->is_address_valid()) 970 return os->address(); 971 *eei->is_valid_pointer = false; 972 return 0; 973 } 974 975 uint64_t 976 value_from_script_output_section(uint64_t address, uint64_t, uint64_t, 977 uint64_t) 978 { return address; } 979 980 const char* 981 function_name() const 982 { return "ADDR"; } 983 }; 984 985 extern "C" Expression* 986 script_exp_function_addr(const char* section_name, size_t section_name_len) 987 { 988 return new Addr_expression(section_name, section_name_len); 989 } 990 991 // ALIGNOF. 992 993 class Alignof_expression : public Section_expression 994 { 995 public: 996 Alignof_expression(const char* section_name, size_t section_name_len) 997 : Section_expression(section_name, section_name_len) 998 { } 999 1000 protected: 1001 uint64_t 1002 value_from_output_section(const Expression_eval_info*, 1003 Output_section* os) 1004 { return os->addralign(); } 1005 1006 uint64_t 1007 value_from_script_output_section(uint64_t, uint64_t, uint64_t addralign, 1008 uint64_t) 1009 { return addralign; } 1010 1011 const char* 1012 function_name() const 1013 { return "ALIGNOF"; } 1014 }; 1015 1016 extern "C" Expression* 1017 script_exp_function_alignof(const char* section_name, size_t section_name_len) 1018 { 1019 return new Alignof_expression(section_name, section_name_len); 1020 } 1021 1022 // CONSTANT. It would be nice if we could simply evaluate this 1023 // immediately and return an Integer_expression, but unfortunately we 1024 // don't know the target. 1025 1026 class Constant_expression : public Expression 1027 { 1028 public: 1029 Constant_expression(const char* name, size_t length); 1030 1031 uint64_t 1032 value(const Expression_eval_info*); 1033 1034 void 1035 print(FILE* f) const; 1036 1037 private: 1038 enum Constant_function 1039 { 1040 CONSTANT_MAXPAGESIZE, 1041 CONSTANT_COMMONPAGESIZE 1042 }; 1043 1044 Constant_function function_; 1045 }; 1046 1047 Constant_expression::Constant_expression(const char* name, size_t length) 1048 { 1049 if (length == 11 && strncmp(name, "MAXPAGESIZE", length) == 0) 1050 this->function_ = CONSTANT_MAXPAGESIZE; 1051 else if (length == 14 && strncmp(name, "COMMONPAGESIZE", length) == 0) 1052 this->function_ = CONSTANT_COMMONPAGESIZE; 1053 else 1054 { 1055 std::string s(name, length); 1056 gold_error(_("unknown constant %s"), s.c_str()); 1057 this->function_ = CONSTANT_MAXPAGESIZE; 1058 } 1059 } 1060 1061 uint64_t 1062 Constant_expression::value(const Expression_eval_info*) 1063 { 1064 switch (this->function_) 1065 { 1066 case CONSTANT_MAXPAGESIZE: 1067 return parameters->target().abi_pagesize(); 1068 case CONSTANT_COMMONPAGESIZE: 1069 return parameters->target().common_pagesize(); 1070 default: 1071 gold_unreachable(); 1072 } 1073 } 1074 1075 void 1076 Constant_expression::print(FILE* f) const 1077 { 1078 const char* name; 1079 switch (this->function_) 1080 { 1081 case CONSTANT_MAXPAGESIZE: 1082 name = "MAXPAGESIZE"; 1083 break; 1084 case CONSTANT_COMMONPAGESIZE: 1085 name = "COMMONPAGESIZE"; 1086 break; 1087 default: 1088 gold_unreachable(); 1089 } 1090 fprintf(f, "CONSTANT(%s)", name); 1091 } 1092 1093 extern "C" Expression* 1094 script_exp_function_constant(const char* name, size_t length) 1095 { 1096 return new Constant_expression(name, length); 1097 } 1098 1099 // DATA_SEGMENT_ALIGN. FIXME: we don't implement this; we always fall 1100 // back to the general case. 1101 1102 extern "C" Expression* 1103 script_exp_function_data_segment_align(Expression* left, Expression*) 1104 { 1105 Expression* e1 = script_exp_function_align(script_exp_string(".", 1), left); 1106 Expression* e2 = script_exp_binary_sub(left, script_exp_integer(1)); 1107 Expression* e3 = script_exp_binary_bitwise_and(script_exp_string(".", 1), 1108 e2); 1109 return script_exp_binary_add(e1, e3); 1110 } 1111 1112 // DATA_SEGMENT_RELRO. FIXME: This is not implemented. 1113 1114 extern "C" Expression* 1115 script_exp_function_data_segment_relro_end(Expression*, Expression* right) 1116 { 1117 return right; 1118 } 1119 1120 // DATA_SEGMENT_END. FIXME: This is not implemented. 1121 1122 extern "C" Expression* 1123 script_exp_function_data_segment_end(Expression* val) 1124 { 1125 return val; 1126 } 1127 1128 // DEFINED function. 1129 1130 class Defined_expression : public Expression 1131 { 1132 public: 1133 Defined_expression(const char* symbol_name, size_t symbol_name_len) 1134 : symbol_name_(symbol_name, symbol_name_len) 1135 { } 1136 1137 uint64_t 1138 value(const Expression_eval_info* eei) 1139 { 1140 Symbol* sym = eei->symtab->lookup(this->symbol_name_.c_str()); 1141 return sym != NULL && sym->is_defined(); 1142 } 1143 1144 void 1145 print(FILE* f) const 1146 { fprintf(f, "DEFINED(%s)", this->symbol_name_.c_str()); } 1147 1148 private: 1149 std::string symbol_name_; 1150 }; 1151 1152 extern "C" Expression* 1153 script_exp_function_defined(const char* symbol_name, size_t symbol_name_len) 1154 { 1155 return new Defined_expression(symbol_name, symbol_name_len); 1156 } 1157 1158 // LOADADDR function 1159 1160 class Loadaddr_expression : public Section_expression 1161 { 1162 public: 1163 Loadaddr_expression(const char* section_name, size_t section_name_len) 1164 : Section_expression(section_name, section_name_len) 1165 { } 1166 1167 protected: 1168 uint64_t 1169 value_from_output_section(const Expression_eval_info* eei, 1170 Output_section* os) 1171 { 1172 if (os->has_load_address()) 1173 return os->load_address(); 1174 else 1175 { 1176 if (eei->result_section_pointer != NULL) 1177 *eei->result_section_pointer = os; 1178 return os->address(); 1179 } 1180 } 1181 1182 uint64_t 1183 value_from_script_output_section(uint64_t, uint64_t load_address, uint64_t, 1184 uint64_t) 1185 { return load_address; } 1186 1187 const char* 1188 function_name() const 1189 { return "LOADADDR"; } 1190 }; 1191 1192 extern "C" Expression* 1193 script_exp_function_loadaddr(const char* section_name, size_t section_name_len) 1194 { 1195 return new Loadaddr_expression(section_name, section_name_len); 1196 } 1197 1198 // SIZEOF function 1199 1200 class Sizeof_expression : public Section_expression 1201 { 1202 public: 1203 Sizeof_expression(const char* section_name, size_t section_name_len) 1204 : Section_expression(section_name, section_name_len) 1205 { } 1206 1207 protected: 1208 uint64_t 1209 value_from_output_section(const Expression_eval_info*, 1210 Output_section* os) 1211 { 1212 // We can not use data_size here, as the size of the section may 1213 // not have been finalized. Instead we get whatever the current 1214 // size is. This will work correctly for backward references in 1215 // linker scripts. 1216 return os->current_data_size(); 1217 } 1218 1219 uint64_t 1220 value_from_script_output_section(uint64_t, uint64_t, uint64_t, 1221 uint64_t size) 1222 { return size; } 1223 1224 const char* 1225 function_name() const 1226 { return "SIZEOF"; } 1227 }; 1228 1229 extern "C" Expression* 1230 script_exp_function_sizeof(const char* section_name, size_t section_name_len) 1231 { 1232 return new Sizeof_expression(section_name, section_name_len); 1233 } 1234 1235 // SIZEOF_HEADERS. 1236 1237 class Sizeof_headers_expression : public Expression 1238 { 1239 public: 1240 Sizeof_headers_expression() 1241 { } 1242 1243 uint64_t 1244 value(const Expression_eval_info*); 1245 1246 void 1247 print(FILE* f) const 1248 { fprintf(f, "SIZEOF_HEADERS"); } 1249 }; 1250 1251 uint64_t 1252 Sizeof_headers_expression::value(const Expression_eval_info* eei) 1253 { 1254 unsigned int ehdr_size; 1255 unsigned int phdr_size; 1256 if (parameters->target().get_size() == 32) 1257 { 1258 ehdr_size = elfcpp::Elf_sizes<32>::ehdr_size; 1259 phdr_size = elfcpp::Elf_sizes<32>::phdr_size; 1260 } 1261 else if (parameters->target().get_size() == 64) 1262 { 1263 ehdr_size = elfcpp::Elf_sizes<64>::ehdr_size; 1264 phdr_size = elfcpp::Elf_sizes<64>::phdr_size; 1265 } 1266 else 1267 gold_unreachable(); 1268 1269 return ehdr_size + phdr_size * eei->layout->expected_segment_count(); 1270 } 1271 1272 extern "C" Expression* 1273 script_exp_function_sizeof_headers() 1274 { 1275 return new Sizeof_headers_expression(); 1276 } 1277 1278 // SEGMENT_START. 1279 1280 class Segment_start_expression : public Unary_expression 1281 { 1282 public: 1283 Segment_start_expression(const char* segment_name, size_t segment_name_len, 1284 Expression* default_value) 1285 : Unary_expression(default_value), 1286 segment_name_(segment_name, segment_name_len) 1287 { } 1288 1289 uint64_t 1290 value(const Expression_eval_info*); 1291 1292 void 1293 print(FILE* f) const 1294 { 1295 fprintf(f, "SEGMENT_START(\"%s\", ", this->segment_name_.c_str()); 1296 this->arg_print(f); 1297 fprintf(f, ")"); 1298 } 1299 1300 private: 1301 std::string segment_name_; 1302 }; 1303 1304 uint64_t 1305 Segment_start_expression::value(const Expression_eval_info* eei) 1306 { 1307 // Check for command line overrides. 1308 if (parameters->options().user_set_Ttext() 1309 && this->segment_name_ == ".text") 1310 return parameters->options().Ttext(); 1311 else if (parameters->options().user_set_Tdata() 1312 && this->segment_name_ == ".data") 1313 return parameters->options().Tdata(); 1314 else if (parameters->options().user_set_Tbss() 1315 && this->segment_name_ == ".bss") 1316 return parameters->options().Tbss(); 1317 else 1318 { 1319 uint64_t ret = this->arg_value(eei, NULL); 1320 // Force the value to be absolute. 1321 if (eei->result_section_pointer != NULL) 1322 *eei->result_section_pointer = NULL; 1323 return ret; 1324 } 1325 } 1326 1327 extern "C" Expression* 1328 script_exp_function_segment_start(const char* segment_name, 1329 size_t segment_name_len, 1330 Expression* default_value) 1331 { 1332 return new Segment_start_expression(segment_name, segment_name_len, 1333 default_value); 1334 } 1335 1336 } // End namespace gold. 1337