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