* elfxx-mips.c (check_4byte_branch): Remove function.
[binutils.git] / gold / expression.cc
blobe527b5e382cd53be2eda1bd16f330a0ffbfed5a2
1 // expression.cc -- expressions in linker scripts for gold
3 // Copyright 2006, 2007, 2008 Free Software Foundation, Inc.
4 // Written by Ian Lance Taylor <iant@google.com>.
6 // This file is part of gold.
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.
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.
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.
23 #include "gold.h"
25 #include <string>
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"
35 namespace gold
38 // This file holds the code which handles linker expressions.
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.
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.
51 struct Expression::Expression_eval_info
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;
73 // Evaluate an expression.
75 uint64_t
76 Expression::eval(const Symbol_table* symtab, const Layout* layout,
77 bool check_assertions)
79 return this->eval_maybe_dot(symtab, layout, check_assertions,
80 false, 0, NULL, NULL, NULL);
83 // Evaluate an expression which may refer to the dot symbol.
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)
92 return this->eval_maybe_dot(symtab, layout, check_assertions, true,
93 dot_value, dot_section, result_section_pointer,
94 result_alignment_pointer);
97 // Evaluate an expression which may or may not refer to the dot
98 // symbol.
100 uint64_t
101 Expression::eval_maybe_dot(const Symbol_table* symtab, const Layout* layout,
102 bool check_assertions, bool is_dot_available,
103 uint64_t dot_value, Output_section* dot_section,
104 Output_section** result_section_pointer,
105 uint64_t* result_alignment_pointer)
107 Expression_eval_info eei;
108 eei.symtab = symtab;
109 eei.layout = layout;
110 eei.check_assertions = check_assertions;
111 eei.is_dot_available = is_dot_available;
112 eei.dot_value = dot_value;
113 eei.dot_section = dot_section;
115 // We assume the value is absolute, and only set this to a section
116 // if we find a section relative reference.
117 if (result_section_pointer != NULL)
118 *result_section_pointer = NULL;
119 eei.result_section_pointer = result_section_pointer;
121 eei.result_alignment_pointer = result_alignment_pointer;
123 return this->value(&eei);
126 // A number.
128 class Integer_expression : public Expression
130 public:
131 Integer_expression(uint64_t val)
132 : val_(val)
135 uint64_t
136 value(const Expression_eval_info*)
137 { return this->val_; }
139 void
140 print(FILE* f) const
141 { fprintf(f, "0x%llx", static_cast<unsigned long long>(this->val_)); }
143 private:
144 uint64_t val_;
147 extern "C" Expression*
148 script_exp_integer(uint64_t val)
150 return new Integer_expression(val);
153 // An expression whose value is the value of a symbol.
155 class Symbol_expression : public Expression
157 public:
158 Symbol_expression(const char* name, size_t length)
159 : name_(name, length)
162 uint64_t
163 value(const Expression_eval_info*);
165 void
166 print(FILE* f) const
167 { fprintf(f, "%s", this->name_.c_str()); }
169 private:
170 std::string name_;
173 uint64_t
174 Symbol_expression::value(const Expression_eval_info* eei)
176 Symbol* sym = eei->symtab->lookup(this->name_.c_str());
177 if (sym == NULL || !sym->is_defined())
179 gold_error(_("undefined symbol '%s' referenced in expression"),
180 this->name_.c_str());
181 return 0;
184 if (eei->result_section_pointer != NULL)
185 *eei->result_section_pointer = sym->output_section();
187 if (parameters->target().get_size() == 32)
188 return eei->symtab->get_sized_symbol<32>(sym)->value();
189 else if (parameters->target().get_size() == 64)
190 return eei->symtab->get_sized_symbol<64>(sym)->value();
191 else
192 gold_unreachable();
195 // An expression whose value is the value of the special symbol ".".
196 // This is only valid within a SECTIONS clause.
198 class Dot_expression : public Expression
200 public:
201 Dot_expression()
204 uint64_t
205 value(const Expression_eval_info*);
207 void
208 print(FILE* f) const
209 { fprintf(f, "."); }
212 uint64_t
213 Dot_expression::value(const Expression_eval_info* eei)
215 if (!eei->is_dot_available)
217 gold_error(_("invalid reference to dot symbol outside of "
218 "SECTIONS clause"));
219 return 0;
221 if (eei->result_section_pointer != NULL)
222 *eei->result_section_pointer = eei->dot_section;
223 return eei->dot_value;
226 // A string. This is either the name of a symbol, or ".".
228 extern "C" Expression*
229 script_exp_string(const char* name, size_t length)
231 if (length == 1 && name[0] == '.')
232 return new Dot_expression();
233 else
234 return new Symbol_expression(name, length);
237 // A unary expression.
239 class Unary_expression : public Expression
241 public:
242 Unary_expression(Expression* arg)
243 : arg_(arg)
246 ~Unary_expression()
247 { delete this->arg_; }
249 protected:
250 uint64_t
251 arg_value(const Expression_eval_info* eei,
252 Output_section** arg_section_pointer) const
254 return this->arg_->eval_maybe_dot(eei->symtab, eei->layout,
255 eei->check_assertions,
256 eei->is_dot_available,
257 eei->dot_value,
258 eei->dot_section,
259 arg_section_pointer,
260 eei->result_alignment_pointer);
263 void
264 arg_print(FILE* f) const
265 { this->arg_->print(f); }
267 private:
268 Expression* arg_;
271 // Handle unary operators. We use a preprocessor macro as a hack to
272 // capture the C operator.
274 #define UNARY_EXPRESSION(NAME, OPERATOR) \
275 class Unary_ ## NAME : public Unary_expression \
277 public: \
278 Unary_ ## NAME(Expression* arg) \
279 : Unary_expression(arg) \
280 { } \
282 uint64_t \
283 value(const Expression_eval_info* eei) \
285 Output_section* arg_section; \
286 uint64_t ret = OPERATOR this->arg_value(eei, &arg_section); \
287 if (arg_section != NULL && parameters->options().relocatable()) \
288 gold_warning(_("unary " #NAME " applied to section " \
289 "relative value")); \
290 return ret; \
293 void \
294 print(FILE* f) const \
296 fprintf(f, "(%s ", #OPERATOR); \
297 this->arg_print(f); \
298 fprintf(f, ")"); \
300 }; \
302 extern "C" Expression* \
303 script_exp_unary_ ## NAME(Expression* arg) \
305 return new Unary_ ## NAME(arg); \
308 UNARY_EXPRESSION(minus, -)
309 UNARY_EXPRESSION(logical_not, !)
310 UNARY_EXPRESSION(bitwise_not, ~)
312 // A binary expression.
314 class Binary_expression : public Expression
316 public:
317 Binary_expression(Expression* left, Expression* right)
318 : left_(left), right_(right)
321 ~Binary_expression()
323 delete this->left_;
324 delete this->right_;
327 protected:
328 uint64_t
329 left_value(const Expression_eval_info* eei,
330 Output_section** section_pointer,
331 uint64_t* alignment_pointer) const
333 return this->left_->eval_maybe_dot(eei->symtab, eei->layout,
334 eei->check_assertions,
335 eei->is_dot_available,
336 eei->dot_value,
337 eei->dot_section,
338 section_pointer,
339 alignment_pointer);
342 uint64_t
343 right_value(const Expression_eval_info* eei,
344 Output_section** section_pointer,
345 uint64_t* alignment_pointer) const
347 return this->right_->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);
356 void
357 left_print(FILE* f) const
358 { this->left_->print(f); }
360 void
361 right_print(FILE* f) const
362 { this->right_->print(f); }
364 // This is a call to function FUNCTION_NAME. Print it. This is for
365 // debugging.
366 void
367 print_function(FILE* f, const char* function_name) const
369 fprintf(f, "%s(", function_name);
370 this->left_print(f);
371 fprintf(f, ", ");
372 this->right_print(f);
373 fprintf(f, ")");
376 private:
377 Expression* left_;
378 Expression* right_;
381 // Handle binary operators. We use a preprocessor macro as a hack to
382 // capture the C operator. KEEP_LEFT means that if the left operand
383 // is section relative and the right operand is not, the result uses
384 // the same section as the left operand. KEEP_RIGHT is the same with
385 // left and right swapped. IS_DIV means that we need to give an error
386 // if the right operand is zero. WARN means that we should warn if
387 // used on section relative values in a relocatable link. We always
388 // warn if used on values in different sections in a relocatable link.
390 #define BINARY_EXPRESSION(NAME, OPERATOR, KEEP_LEFT, KEEP_RIGHT, IS_DIV, WARN) \
391 class Binary_ ## NAME : public Binary_expression \
393 public: \
394 Binary_ ## NAME(Expression* left, Expression* right) \
395 : Binary_expression(left, right) \
396 { } \
398 uint64_t \
399 value(const Expression_eval_info* eei) \
401 Output_section* left_section; \
402 uint64_t left_alignment = 0; \
403 uint64_t left = this->left_value(eei, &left_section, \
404 &left_alignment); \
405 Output_section* right_section; \
406 uint64_t right_alignment = 0; \
407 uint64_t right = this->right_value(eei, &right_section, \
408 &right_alignment); \
409 if (KEEP_RIGHT && left_section == NULL && right_section != NULL) \
411 if (eei->result_section_pointer != NULL) \
412 *eei->result_section_pointer = right_section; \
413 if (eei->result_alignment_pointer != NULL \
414 && right_alignment > *eei->result_alignment_pointer) \
415 *eei->result_alignment_pointer = right_alignment; \
417 else if (KEEP_LEFT \
418 && left_section != NULL \
419 && right_section == NULL) \
421 if (eei->result_section_pointer != NULL) \
422 *eei->result_section_pointer = left_section; \
423 if (eei->result_alignment_pointer != NULL \
424 && left_alignment > *eei->result_alignment_pointer) \
425 *eei->result_alignment_pointer = left_alignment; \
427 else if ((WARN || left_section != right_section) \
428 && (left_section != NULL || right_section != NULL) \
429 && parameters->options().relocatable()) \
430 gold_warning(_("binary " #NAME " applied to section " \
431 "relative value")); \
432 if (IS_DIV && right == 0) \
434 gold_error(_(#NAME " by zero")); \
435 return 0; \
437 return left OPERATOR right; \
440 void \
441 print(FILE* f) const \
443 fprintf(f, "("); \
444 this->left_print(f); \
445 fprintf(f, " %s ", #OPERATOR); \
446 this->right_print(f); \
447 fprintf(f, ")"); \
449 }; \
451 extern "C" Expression* \
452 script_exp_binary_ ## NAME(Expression* left, Expression* right) \
454 return new Binary_ ## NAME(left, right); \
457 BINARY_EXPRESSION(mult, *, false, false, false, true)
458 BINARY_EXPRESSION(div, /, false, false, true, true)
459 BINARY_EXPRESSION(mod, %, false, false, true, true)
460 BINARY_EXPRESSION(add, +, true, true, false, true)
461 BINARY_EXPRESSION(sub, -, true, false, false, false)
462 BINARY_EXPRESSION(lshift, <<, false, false, false, true)
463 BINARY_EXPRESSION(rshift, >>, false, false, false, true)
464 BINARY_EXPRESSION(eq, ==, false, false, false, false)
465 BINARY_EXPRESSION(ne, !=, false, false, false, false)
466 BINARY_EXPRESSION(le, <=, false, false, false, false)
467 BINARY_EXPRESSION(ge, >=, false, false, false, false)
468 BINARY_EXPRESSION(lt, <, false, false, false, false)
469 BINARY_EXPRESSION(gt, >, false, false, false, false)
470 BINARY_EXPRESSION(bitwise_and, &, true, true, false, true)
471 BINARY_EXPRESSION(bitwise_xor, ^, true, true, false, true)
472 BINARY_EXPRESSION(bitwise_or, |, true, true, false, true)
473 BINARY_EXPRESSION(logical_and, &&, false, false, false, true)
474 BINARY_EXPRESSION(logical_or, ||, false, false, false, true)
476 // A trinary expression.
478 class Trinary_expression : public Expression
480 public:
481 Trinary_expression(Expression* arg1, Expression* arg2, Expression* arg3)
482 : arg1_(arg1), arg2_(arg2), arg3_(arg3)
485 ~Trinary_expression()
487 delete this->arg1_;
488 delete this->arg2_;
489 delete this->arg3_;
492 protected:
493 uint64_t
494 arg1_value(const Expression_eval_info* eei,
495 Output_section** section_pointer) const
497 return this->arg1_->eval_maybe_dot(eei->symtab, eei->layout,
498 eei->check_assertions,
499 eei->is_dot_available,
500 eei->dot_value,
501 eei->dot_section,
502 section_pointer,
503 NULL);
506 uint64_t
507 arg2_value(const Expression_eval_info* eei,
508 Output_section** section_pointer,
509 uint64_t* alignment_pointer) const
511 return this->arg1_->eval_maybe_dot(eei->symtab, eei->layout,
512 eei->check_assertions,
513 eei->is_dot_available,
514 eei->dot_value,
515 eei->dot_section,
516 section_pointer,
517 alignment_pointer);
520 uint64_t
521 arg3_value(const Expression_eval_info* eei,
522 Output_section** section_pointer,
523 uint64_t* alignment_pointer) const
525 return this->arg1_->eval_maybe_dot(eei->symtab, eei->layout,
526 eei->check_assertions,
527 eei->is_dot_available,
528 eei->dot_value,
529 eei->dot_section,
530 section_pointer,
531 alignment_pointer);
534 void
535 arg1_print(FILE* f) const
536 { this->arg1_->print(f); }
538 void
539 arg2_print(FILE* f) const
540 { this->arg2_->print(f); }
542 void
543 arg3_print(FILE* f) const
544 { this->arg3_->print(f); }
546 private:
547 Expression* arg1_;
548 Expression* arg2_;
549 Expression* arg3_;
552 // The conditional operator.
554 class Trinary_cond : public Trinary_expression
556 public:
557 Trinary_cond(Expression* arg1, Expression* arg2, Expression* arg3)
558 : Trinary_expression(arg1, arg2, arg3)
561 uint64_t
562 value(const Expression_eval_info* eei)
564 Output_section* arg1_section;
565 uint64_t arg1 = this->arg1_value(eei, &arg1_section);
566 return (arg1
567 ? this->arg2_value(eei, eei->result_section_pointer,
568 eei->result_alignment_pointer)
569 : this->arg3_value(eei, eei->result_section_pointer,
570 eei->result_alignment_pointer));
573 void
574 print(FILE* f) const
576 fprintf(f, "(");
577 this->arg1_print(f);
578 fprintf(f, " ? ");
579 this->arg2_print(f);
580 fprintf(f, " : ");
581 this->arg3_print(f);
582 fprintf(f, ")");
586 extern "C" Expression*
587 script_exp_trinary_cond(Expression* arg1, Expression* arg2, Expression* arg3)
589 return new Trinary_cond(arg1, arg2, arg3);
592 // Max function.
594 class Max_expression : public Binary_expression
596 public:
597 Max_expression(Expression* left, Expression* right)
598 : Binary_expression(left, right)
601 uint64_t
602 value(const Expression_eval_info* eei)
604 Output_section* left_section;
605 uint64_t left_alignment;
606 uint64_t left = this->left_value(eei, &left_section, &left_alignment);
607 Output_section* right_section;
608 uint64_t right_alignment;
609 uint64_t right = this->right_value(eei, &right_section, &right_alignment);
610 if (left_section == right_section)
612 if (eei->result_section_pointer != NULL)
613 *eei->result_section_pointer = left_section;
615 else if ((left_section != NULL || right_section != NULL)
616 && parameters->options().relocatable())
617 gold_warning(_("max applied to section relative value"));
618 if (eei->result_alignment_pointer != NULL)
620 uint64_t ra = *eei->result_alignment_pointer;
621 if (left > right)
622 ra = std::max(ra, left_alignment);
623 else if (right > left)
624 ra = std::max(ra, right_alignment);
625 else
626 ra = std::max(ra, std::max(left_alignment, right_alignment));
627 *eei->result_alignment_pointer = ra;
629 return std::max(left, right);
632 void
633 print(FILE* f) const
634 { this->print_function(f, "MAX"); }
637 extern "C" Expression*
638 script_exp_function_max(Expression* left, Expression* right)
640 return new Max_expression(left, right);
643 // Min function.
645 class Min_expression : public Binary_expression
647 public:
648 Min_expression(Expression* left, Expression* right)
649 : Binary_expression(left, right)
652 uint64_t
653 value(const Expression_eval_info* eei)
655 Output_section* left_section;
656 uint64_t left_alignment;
657 uint64_t left = this->left_value(eei, &left_section, &left_alignment);
658 Output_section* right_section;
659 uint64_t right_alignment;
660 uint64_t right = this->right_value(eei, &right_section, &right_alignment);
661 if (left_section == right_section)
663 if (eei->result_section_pointer != NULL)
664 *eei->result_section_pointer = left_section;
666 else if ((left_section != NULL || right_section != NULL)
667 && parameters->options().relocatable())
668 gold_warning(_("min applied to section relative value"));
669 if (eei->result_alignment_pointer != NULL)
671 uint64_t ra = *eei->result_alignment_pointer;
672 if (left < right)
673 ra = std::max(ra, left_alignment);
674 else if (right < left)
675 ra = std::max(ra, right_alignment);
676 else
677 ra = std::max(ra, std::max(left_alignment, right_alignment));
678 *eei->result_alignment_pointer = ra;
680 return std::min(left, right);
683 void
684 print(FILE* f) const
685 { this->print_function(f, "MIN"); }
688 extern "C" Expression*
689 script_exp_function_min(Expression* left, Expression* right)
691 return new Min_expression(left, right);
694 // Class Section_expression. This is a parent class used for
695 // functions which take the name of an output section.
697 class Section_expression : public Expression
699 public:
700 Section_expression(const char* section_name, size_t section_name_len)
701 : section_name_(section_name, section_name_len)
704 uint64_t
705 value(const Expression_eval_info*);
707 void
708 print(FILE* f) const
709 { fprintf(f, "%s(%s)", this->function_name(), this->section_name_.c_str()); }
711 protected:
712 // The child class must implement this.
713 virtual uint64_t
714 value_from_output_section(const Expression_eval_info*,
715 Output_section*) = 0;
717 // The child class must implement this.
718 virtual uint64_t
719 value_from_script_output_section(uint64_t address, uint64_t load_address,
720 uint64_t addralign, uint64_t size) = 0;
722 // The child class must implement this.
723 virtual const char*
724 function_name() const = 0;
726 private:
727 std::string section_name_;
730 uint64_t
731 Section_expression::value(const Expression_eval_info* eei)
733 const char* section_name = this->section_name_.c_str();
734 Output_section* os = eei->layout->find_output_section(section_name);
735 if (os != NULL)
736 return this->value_from_output_section(eei, os);
738 uint64_t address;
739 uint64_t load_address;
740 uint64_t addralign;
741 uint64_t size;
742 const Script_options* ss = eei->layout->script_options();
743 if (ss->saw_sections_clause())
745 if (ss->script_sections()->get_output_section_info(section_name,
746 &address,
747 &load_address,
748 &addralign,
749 &size))
750 return this->value_from_script_output_section(address, load_address,
751 addralign, size);
754 gold_error("%s called on nonexistent output section '%s'",
755 this->function_name(), section_name);
756 return 0;
759 // ABSOLUTE function.
761 class Absolute_expression : public Unary_expression
763 public:
764 Absolute_expression(Expression* arg)
765 : Unary_expression(arg)
768 uint64_t
769 value(const Expression_eval_info* eei)
771 uint64_t ret = this->arg_value(eei, NULL);
772 // Force the value to be absolute.
773 if (eei->result_section_pointer != NULL)
774 *eei->result_section_pointer = NULL;
775 return ret;
778 void
779 print(FILE* f) const
781 fprintf(f, "ABSOLUTE(");
782 this->arg_print(f);
783 fprintf(f, ")");
787 extern "C" Expression*
788 script_exp_function_absolute(Expression* arg)
790 return new Absolute_expression(arg);
793 // ALIGN function.
795 class Align_expression : public Binary_expression
797 public:
798 Align_expression(Expression* left, Expression* right)
799 : Binary_expression(left, right)
802 uint64_t
803 value(const Expression_eval_info* eei)
805 Output_section* align_section;
806 uint64_t align = this->right_value(eei, &align_section, NULL);
807 if (align_section != NULL
808 && parameters->options().relocatable())
809 gold_warning(_("aligning to section relative value"));
811 if (eei->result_alignment_pointer != NULL
812 && align > *eei->result_alignment_pointer)
814 uint64_t a = align;
815 while ((a & (a - 1)) != 0)
816 a &= a - 1;
817 *eei->result_alignment_pointer = a;
820 uint64_t value = this->left_value(eei, eei->result_section_pointer, NULL);
821 if (align <= 1)
822 return value;
823 return ((value + align - 1) / align) * align;
826 void
827 print(FILE* f) const
828 { this->print_function(f, "ALIGN"); }
831 extern "C" Expression*
832 script_exp_function_align(Expression* left, Expression* right)
834 return new Align_expression(left, right);
837 // ASSERT function.
839 class Assert_expression : public Unary_expression
841 public:
842 Assert_expression(Expression* arg, const char* message, size_t length)
843 : Unary_expression(arg), message_(message, length)
846 uint64_t
847 value(const Expression_eval_info* eei)
849 uint64_t value = this->arg_value(eei, eei->result_section_pointer);
850 if (!value && eei->check_assertions)
851 gold_error("%s", this->message_.c_str());
852 return value;
855 void
856 print(FILE* f) const
858 fprintf(f, "ASSERT(");
859 this->arg_print(f);
860 fprintf(f, ", %s)", this->message_.c_str());
863 private:
864 std::string message_;
867 extern "C" Expression*
868 script_exp_function_assert(Expression* expr, const char* message,
869 size_t length)
871 return new Assert_expression(expr, message, length);
874 // ADDR function.
876 class Addr_expression : public Section_expression
878 public:
879 Addr_expression(const char* section_name, size_t section_name_len)
880 : Section_expression(section_name, section_name_len)
883 protected:
884 uint64_t
885 value_from_output_section(const Expression_eval_info* eei,
886 Output_section* os)
888 if (eei->result_section_pointer != NULL)
889 *eei->result_section_pointer = os;
890 return os->address();
893 uint64_t
894 value_from_script_output_section(uint64_t address, uint64_t, uint64_t,
895 uint64_t)
896 { return address; }
898 const char*
899 function_name() const
900 { return "ADDR"; }
903 extern "C" Expression*
904 script_exp_function_addr(const char* section_name, size_t section_name_len)
906 return new Addr_expression(section_name, section_name_len);
909 // ALIGNOF.
911 class Alignof_expression : public Section_expression
913 public:
914 Alignof_expression(const char* section_name, size_t section_name_len)
915 : Section_expression(section_name, section_name_len)
918 protected:
919 uint64_t
920 value_from_output_section(const Expression_eval_info*,
921 Output_section* os)
922 { return os->addralign(); }
924 uint64_t
925 value_from_script_output_section(uint64_t, uint64_t, uint64_t addralign,
926 uint64_t)
927 { return addralign; }
929 const char*
930 function_name() const
931 { return "ALIGNOF"; }
934 extern "C" Expression*
935 script_exp_function_alignof(const char* section_name, size_t section_name_len)
937 return new Alignof_expression(section_name, section_name_len);
940 // CONSTANT. It would be nice if we could simply evaluate this
941 // immediately and return an Integer_expression, but unfortunately we
942 // don't know the target.
944 class Constant_expression : public Expression
946 public:
947 Constant_expression(const char* name, size_t length);
949 uint64_t
950 value(const Expression_eval_info*);
952 void
953 print(FILE* f) const;
955 private:
956 enum Constant_function
958 CONSTANT_MAXPAGESIZE,
959 CONSTANT_COMMONPAGESIZE
962 Constant_function function_;
965 Constant_expression::Constant_expression(const char* name, size_t length)
967 if (length == 11 && strncmp(name, "MAXPAGESIZE", length) == 0)
968 this->function_ = CONSTANT_MAXPAGESIZE;
969 else if (length == 14 && strncmp(name, "COMMONPAGESIZE", length) == 0)
970 this->function_ = CONSTANT_COMMONPAGESIZE;
971 else
973 std::string s(name, length);
974 gold_error(_("unknown constant %s"), s.c_str());
975 this->function_ = CONSTANT_MAXPAGESIZE;
979 uint64_t
980 Constant_expression::value(const Expression_eval_info*)
982 switch (this->function_)
984 case CONSTANT_MAXPAGESIZE:
985 return parameters->target().abi_pagesize();
986 case CONSTANT_COMMONPAGESIZE:
987 return parameters->target().common_pagesize();
988 default:
989 gold_unreachable();
993 void
994 Constant_expression::print(FILE* f) const
996 const char* name;
997 switch (this->function_)
999 case CONSTANT_MAXPAGESIZE:
1000 name = "MAXPAGESIZE";
1001 break;
1002 case CONSTANT_COMMONPAGESIZE:
1003 name = "COMMONPAGESIZE";
1004 break;
1005 default:
1006 gold_unreachable();
1008 fprintf(f, "CONSTANT(%s)", name);
1011 extern "C" Expression*
1012 script_exp_function_constant(const char* name, size_t length)
1014 return new Constant_expression(name, length);
1017 // DATA_SEGMENT_ALIGN. FIXME: we don't implement this; we always fall
1018 // back to the general case.
1020 extern "C" Expression*
1021 script_exp_function_data_segment_align(Expression* left, Expression*)
1023 Expression* e1 = script_exp_function_align(script_exp_string(".", 1), left);
1024 Expression* e2 = script_exp_binary_sub(left, script_exp_integer(1));
1025 Expression* e3 = script_exp_binary_bitwise_and(script_exp_string(".", 1),
1026 e2);
1027 return script_exp_binary_add(e1, e3);
1030 // DATA_SEGMENT_RELRO. FIXME: This is not implemented.
1032 extern "C" Expression*
1033 script_exp_function_data_segment_relro_end(Expression*, Expression* right)
1035 return right;
1038 // DATA_SEGMENT_END. FIXME: This is not implemented.
1040 extern "C" Expression*
1041 script_exp_function_data_segment_end(Expression* val)
1043 return val;
1046 // DEFINED function.
1048 class Defined_expression : public Expression
1050 public:
1051 Defined_expression(const char* symbol_name, size_t symbol_name_len)
1052 : symbol_name_(symbol_name, symbol_name_len)
1055 uint64_t
1056 value(const Expression_eval_info* eei)
1058 Symbol* sym = eei->symtab->lookup(this->symbol_name_.c_str());
1059 return sym != NULL && sym->is_defined();
1062 void
1063 print(FILE* f) const
1064 { fprintf(f, "DEFINED(%s)", this->symbol_name_.c_str()); }
1066 private:
1067 std::string symbol_name_;
1070 extern "C" Expression*
1071 script_exp_function_defined(const char* symbol_name, size_t symbol_name_len)
1073 return new Defined_expression(symbol_name, symbol_name_len);
1076 // LOADADDR function
1078 class Loadaddr_expression : public Section_expression
1080 public:
1081 Loadaddr_expression(const char* section_name, size_t section_name_len)
1082 : Section_expression(section_name, section_name_len)
1085 protected:
1086 uint64_t
1087 value_from_output_section(const Expression_eval_info* eei,
1088 Output_section* os)
1090 if (os->has_load_address())
1091 return os->load_address();
1092 else
1094 if (eei->result_section_pointer != NULL)
1095 *eei->result_section_pointer = os;
1096 return os->address();
1100 uint64_t
1101 value_from_script_output_section(uint64_t, uint64_t load_address, uint64_t,
1102 uint64_t)
1103 { return load_address; }
1105 const char*
1106 function_name() const
1107 { return "LOADADDR"; }
1110 extern "C" Expression*
1111 script_exp_function_loadaddr(const char* section_name, size_t section_name_len)
1113 return new Loadaddr_expression(section_name, section_name_len);
1116 // SIZEOF function
1118 class Sizeof_expression : public Section_expression
1120 public:
1121 Sizeof_expression(const char* section_name, size_t section_name_len)
1122 : Section_expression(section_name, section_name_len)
1125 protected:
1126 uint64_t
1127 value_from_output_section(const Expression_eval_info*,
1128 Output_section* os)
1130 // We can not use data_size here, as the size of the section may
1131 // not have been finalized. Instead we get whatever the current
1132 // size is. This will work correctly for backward references in
1133 // linker scripts.
1134 return os->current_data_size();
1137 uint64_t
1138 value_from_script_output_section(uint64_t, uint64_t, uint64_t,
1139 uint64_t size)
1140 { return size; }
1142 const char*
1143 function_name() const
1144 { return "SIZEOF"; }
1147 extern "C" Expression*
1148 script_exp_function_sizeof(const char* section_name, size_t section_name_len)
1150 return new Sizeof_expression(section_name, section_name_len);
1153 // SIZEOF_HEADERS.
1155 class Sizeof_headers_expression : public Expression
1157 public:
1158 Sizeof_headers_expression()
1161 uint64_t
1162 value(const Expression_eval_info*);
1164 void
1165 print(FILE* f) const
1166 { fprintf(f, "SIZEOF_HEADERS"); }
1169 uint64_t
1170 Sizeof_headers_expression::value(const Expression_eval_info* eei)
1172 unsigned int ehdr_size;
1173 unsigned int phdr_size;
1174 if (parameters->target().get_size() == 32)
1176 ehdr_size = elfcpp::Elf_sizes<32>::ehdr_size;
1177 phdr_size = elfcpp::Elf_sizes<32>::phdr_size;
1179 else if (parameters->target().get_size() == 64)
1181 ehdr_size = elfcpp::Elf_sizes<64>::ehdr_size;
1182 phdr_size = elfcpp::Elf_sizes<64>::phdr_size;
1184 else
1185 gold_unreachable();
1187 return ehdr_size + phdr_size * eei->layout->expected_segment_count();
1190 extern "C" Expression*
1191 script_exp_function_sizeof_headers()
1193 return new Sizeof_headers_expression();
1196 // SEGMENT_START.
1198 class Segment_start_expression : public Unary_expression
1200 public:
1201 Segment_start_expression(const char* segment_name, size_t segment_name_len,
1202 Expression* default_value)
1203 : Unary_expression(default_value),
1204 segment_name_(segment_name, segment_name_len)
1207 uint64_t
1208 value(const Expression_eval_info*);
1210 void
1211 print(FILE* f) const
1213 fprintf(f, "SEGMENT_START(\"%s\", ", this->segment_name_.c_str());
1214 this->arg_print(f);
1215 fprintf(f, ")");
1218 private:
1219 std::string segment_name_;
1222 uint64_t
1223 Segment_start_expression::value(const Expression_eval_info* eei)
1225 // Check for command line overrides.
1226 if (parameters->options().user_set_Ttext()
1227 && this->segment_name_ == ".text")
1228 return parameters->options().Ttext();
1229 else if (parameters->options().user_set_Tdata()
1230 && this->segment_name_ == ".data")
1231 return parameters->options().Tdata();
1232 else if (parameters->options().user_set_Tbss()
1233 && this->segment_name_ == ".bss")
1234 return parameters->options().Tbss();
1235 else
1237 uint64_t ret = this->arg_value(eei, NULL);
1238 // Force the value to be absolute.
1239 if (eei->result_section_pointer != NULL)
1240 *eei->result_section_pointer = NULL;
1241 return ret;
1245 extern "C" Expression*
1246 script_exp_function_segment_start(const char* segment_name,
1247 size_t segment_name_len,
1248 Expression* default_value)
1250 return new Segment_start_expression(segment_name, segment_name_len,
1251 default_value);
1254 } // End namespace gold.