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