gold/expression.cc

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