1 /* This module handles expression trees.
2 Copyright (C) 1991-2016 Free Software Foundation, Inc.
3 Written by Steve Chamberlain of Cygnus Support <sac@cygnus.com>.
5 This file is part of the GNU Binutils.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20 MA 02110-1301, USA. */
23 /* This module is in charge of working out the contents of expressions.
25 It has to keep track of the relative/absness of a symbol etc. This
26 is done by keeping all values in a struct (an etree_value_type)
27 which contains a value, a section to which it is relative and a
41 #include "libiberty.h"
42 #include "safe-ctype.h"
44 static void exp_fold_tree_1 (etree_type *);
45 static bfd_vma align_n (bfd_vma, bfd_vma);
47 segment_type *segments;
49 struct ldexp_control expld;
51 /* This structure records symbols for which we need to keep track of
52 definedness for use in the DEFINED () test. It is also used in
53 making absolute symbols section relative late in the link. */
55 struct definedness_hash_entry
57 struct bfd_hash_entry root;
59 /* If this symbol was assigned from "dot" outside of an output
60 section statement, the section we'd like it relative to. */
63 /* Symbol was defined by an object file. */
64 unsigned int by_object : 1;
66 /* Symbols was defined by a script. */
67 unsigned int by_script : 1;
69 /* Low bit of iteration count. Symbols with matching iteration have
70 been defined in this pass over the script. */
71 unsigned int iteration : 1;
74 static struct bfd_hash_table definedness_table;
76 /* Print the string representation of the given token. Surround it
77 with spaces if INFIX_P is TRUE. */
80 exp_print_token (token_code_type code, int infix_p)
107 { LOG2CEIL, "LOG2CEIL" },
108 { ALIGN_K, "ALIGN" },
115 { SECTIONS, "SECTIONS" },
116 { SIZEOF_HEADERS, "SIZEOF_HEADERS" },
117 { MEMORY, "MEMORY" },
118 { DEFINED, "DEFINED" },
119 { TARGET_K, "TARGET" },
120 { SEARCH_DIR, "SEARCH_DIR" },
124 { ALIGNOF, "ALIGNOF" },
125 { SIZEOF, "SIZEOF" },
127 { LOADADDR, "LOADADDR" },
128 { CONSTANT, "CONSTANT" },
129 { ABSOLUTE, "ABSOLUTE" },
132 { ASSERT_K, "ASSERT" },
133 { REL, "relocatable" },
134 { DATA_SEGMENT_ALIGN, "DATA_SEGMENT_ALIGN" },
135 { DATA_SEGMENT_RELRO_END, "DATA_SEGMENT_RELRO_END" },
136 { DATA_SEGMENT_END, "DATA_SEGMENT_END" },
137 { ORIGIN, "ORIGIN" },
138 { LENGTH, "LENGTH" },
139 { SEGMENT_START, "SEGMENT_START" }
143 for (idx = 0; idx < ARRAY_SIZE (table); idx++)
144 if (table[idx].code == code)
148 fputc (' ', config.map_file);
150 if (idx < ARRAY_SIZE (table))
151 fputs (table[idx].name, config.map_file);
153 fputc (code, config.map_file);
155 fprintf (config.map_file, "<code %d>", code);
158 fputc (' ', config.map_file);
164 bfd_vma value = expld.result.value;
166 bfd_boolean round_up = FALSE;
171 /* If more than one bit is set in the value we will need to round up. */
172 if ((value > 1) && (value & 1))
179 expld.result.section = NULL;
180 expld.result.value = result;
186 if (expld.result.section != NULL)
187 expld.result.value += expld.result.section->vma;
188 expld.result.section = bfd_abs_section_ptr;
189 expld.rel_from_abs = FALSE;
193 new_abs (bfd_vma value)
195 expld.result.valid_p = TRUE;
196 expld.result.section = bfd_abs_section_ptr;
197 expld.result.value = value;
198 expld.result.str = NULL;
202 exp_intop (bfd_vma value)
204 etree_type *new_e = (etree_type *) stat_alloc (sizeof (new_e->value));
205 new_e->type.node_code = INT;
206 new_e->type.filename = ldlex_filename ();
207 new_e->type.lineno = lineno;
208 new_e->value.value = value;
209 new_e->value.str = NULL;
210 new_e->type.node_class = etree_value;
215 exp_bigintop (bfd_vma value, char *str)
217 etree_type *new_e = (etree_type *) stat_alloc (sizeof (new_e->value));
218 new_e->type.node_code = INT;
219 new_e->type.filename = ldlex_filename ();
220 new_e->type.lineno = lineno;
221 new_e->value.value = value;
222 new_e->value.str = str;
223 new_e->type.node_class = etree_value;
227 /* Build an expression representing an unnamed relocatable value. */
230 exp_relop (asection *section, bfd_vma value)
232 etree_type *new_e = (etree_type *) stat_alloc (sizeof (new_e->rel));
233 new_e->type.node_code = REL;
234 new_e->type.filename = ldlex_filename ();
235 new_e->type.lineno = lineno;
236 new_e->type.node_class = etree_rel;
237 new_e->rel.section = section;
238 new_e->rel.value = value;
243 new_number (bfd_vma value)
245 expld.result.valid_p = TRUE;
246 expld.result.value = value;
247 expld.result.str = NULL;
248 expld.result.section = NULL;
252 new_rel (bfd_vma value, asection *section)
254 expld.result.valid_p = TRUE;
255 expld.result.value = value;
256 expld.result.str = NULL;
257 expld.result.section = section;
261 new_rel_from_abs (bfd_vma value)
263 asection *s = expld.section;
265 expld.rel_from_abs = TRUE;
266 expld.result.valid_p = TRUE;
267 expld.result.value = value - s->vma;
268 expld.result.str = NULL;
269 expld.result.section = s;
272 /* New-function for the definedness hash table. */
274 static struct bfd_hash_entry *
275 definedness_newfunc (struct bfd_hash_entry *entry,
276 struct bfd_hash_table *table ATTRIBUTE_UNUSED,
277 const char *name ATTRIBUTE_UNUSED)
279 struct definedness_hash_entry *ret = (struct definedness_hash_entry *) entry;
282 ret = (struct definedness_hash_entry *)
283 bfd_hash_allocate (table, sizeof (struct definedness_hash_entry));
286 einfo (_("%P%F: bfd_hash_allocate failed creating symbol %s\n"), name);
294 /* Called during processing of linker script script expressions.
295 For symbols assigned in a linker script, return a struct describing
296 where the symbol is defined relative to the current expression,
297 otherwise return NULL. */
299 static struct definedness_hash_entry *
300 symbol_defined (const char *name)
302 return ((struct definedness_hash_entry *)
303 bfd_hash_lookup (&definedness_table, name, FALSE, FALSE));
306 /* Update the definedness state of NAME. Return FALSE if script symbol
307 is multiply defining a strong symbol in an object. */
310 update_definedness (const char *name, struct bfd_link_hash_entry *h)
313 struct definedness_hash_entry *defentry
314 = (struct definedness_hash_entry *)
315 bfd_hash_lookup (&definedness_table, name, TRUE, FALSE);
317 if (defentry == NULL)
318 einfo (_("%P%F: bfd_hash_lookup failed creating symbol %s\n"), name);
320 /* If the symbol was already defined, and not by a script, then it
321 must be defined by an object file or by the linker target code. */
323 if (!defentry->by_script
324 && (h->type == bfd_link_hash_defined
325 || h->type == bfd_link_hash_defweak
326 || h->type == bfd_link_hash_common))
328 defentry->by_object = 1;
329 if (h->type == bfd_link_hash_defined
330 && h->u.def.section->output_section != NULL
335 defentry->by_script = 1;
336 defentry->iteration = lang_statement_iteration;
337 defentry->final_sec = bfd_abs_section_ptr;
338 if (expld.phase == lang_final_phase_enum
339 && expld.rel_from_abs
340 && expld.result.section == bfd_abs_section_ptr)
341 defentry->final_sec = section_for_dot ();
346 fold_unary (etree_type *tree)
348 exp_fold_tree_1 (tree->unary.child);
349 if (expld.result.valid_p)
351 switch (tree->type.node_code)
354 if (expld.phase != lang_first_phase_enum)
355 new_rel_from_abs (align_n (expld.dot, expld.result.value));
357 expld.result.valid_p = FALSE;
369 expld.result.value = ~expld.result.value;
373 expld.result.value = !expld.result.value;
377 expld.result.value = -expld.result.value;
381 /* Return next place aligned to value. */
382 if (expld.phase != lang_first_phase_enum)
385 expld.result.value = align_n (expld.dot, expld.result.value);
388 expld.result.valid_p = FALSE;
391 case DATA_SEGMENT_END:
392 if (expld.phase == lang_first_phase_enum
393 || expld.section != bfd_abs_section_ptr)
395 expld.result.valid_p = FALSE;
397 else if (expld.dataseg.phase == exp_dataseg_align_seen
398 || expld.dataseg.phase == exp_dataseg_relro_seen)
400 expld.dataseg.phase = exp_dataseg_end_seen;
401 expld.dataseg.end = expld.result.value;
403 else if (expld.dataseg.phase == exp_dataseg_done
404 || expld.dataseg.phase == exp_dataseg_adjust
405 || expld.dataseg.phase == exp_dataseg_relro_adjust)
410 expld.result.valid_p = FALSE;
421 fold_binary (etree_type *tree)
423 etree_value_type lhs;
424 exp_fold_tree_1 (tree->binary.lhs);
426 /* The SEGMENT_START operator is special because its first
427 operand is a string, not the name of a symbol. Note that the
428 operands have been swapped, so binary.lhs is second (default)
429 operand, binary.rhs is first operand. */
430 if (expld.result.valid_p && tree->type.node_code == SEGMENT_START)
432 const char *segment_name;
435 /* Check to see if the user has overridden the default
437 segment_name = tree->binary.rhs->name.name;
438 for (seg = segments; seg; seg = seg->next)
439 if (strcmp (seg->name, segment_name) == 0)
442 && config.magic_demand_paged
443 && (seg->value % config.maxpagesize) != 0)
444 einfo (_("%P: warning: address of `%s' "
445 "isn't multiple of maximum page size\n"),
448 new_rel_from_abs (seg->value);
455 exp_fold_tree_1 (tree->binary.rhs);
456 expld.result.valid_p &= lhs.valid_p;
458 if (expld.result.valid_p)
460 if (lhs.section != expld.result.section)
462 /* If the values are from different sections, and neither is
463 just a number, make both the source arguments absolute. */
464 if (expld.result.section != NULL
465 && lhs.section != NULL)
468 lhs.value += lhs.section->vma;
469 lhs.section = bfd_abs_section_ptr;
472 /* If the rhs is just a number, keep the lhs section. */
473 else if (expld.result.section == NULL)
475 expld.result.section = lhs.section;
476 /* Make this NULL so that we know one of the operands
477 was just a number, for later tests. */
481 /* At this point we know that both operands have the same
482 section, or at least one of them is a plain number. */
484 switch (tree->type.node_code)
486 /* Arithmetic operators, bitwise AND, bitwise OR and XOR
487 keep the section of one of their operands only when the
488 other operand is a plain number. Losing the section when
489 operating on two symbols, ie. a result of a plain number,
490 is required for subtraction and XOR. It's justifiable
491 for the other operations on the grounds that adding,
492 multiplying etc. two section relative values does not
493 really make sense unless they are just treated as
495 The same argument could be made for many expressions
496 involving one symbol and a number. For example,
497 "1 << x" and "100 / x" probably should not be given the
498 section of x. The trouble is that if we fuss about such
499 things the rules become complex and it is onerous to
500 document ld expression evaluation. */
503 expld.result.value = lhs.value y expld.result.value; \
504 if (expld.result.section == lhs.section) \
505 expld.result.section = NULL; \
508 /* Comparison operators, logical AND, and logical OR always
509 return a plain number. */
512 expld.result.value = lhs.value y expld.result.value; \
513 expld.result.section = NULL; \
534 if (expld.result.value != 0)
535 expld.result.value = ((bfd_signed_vma) lhs.value
536 % (bfd_signed_vma) expld.result.value);
537 else if (expld.phase != lang_mark_phase_enum)
538 einfo (_("%F%S %% by zero\n"), tree->binary.rhs);
539 if (expld.result.section == lhs.section)
540 expld.result.section = NULL;
544 if (expld.result.value != 0)
545 expld.result.value = ((bfd_signed_vma) lhs.value
546 / (bfd_signed_vma) expld.result.value);
547 else if (expld.phase != lang_mark_phase_enum)
548 einfo (_("%F%S / by zero\n"), tree->binary.rhs);
549 if (expld.result.section == lhs.section)
550 expld.result.section = NULL;
554 if (lhs.value > expld.result.value)
555 expld.result.value = lhs.value;
559 if (lhs.value < expld.result.value)
560 expld.result.value = lhs.value;
564 expld.result.value = align_n (lhs.value, expld.result.value);
567 case DATA_SEGMENT_ALIGN:
568 expld.dataseg.relro = exp_dataseg_relro_start;
569 if (expld.phase == lang_first_phase_enum
570 || expld.section != bfd_abs_section_ptr)
571 expld.result.valid_p = FALSE;
574 bfd_vma maxpage = lhs.value;
575 bfd_vma commonpage = expld.result.value;
577 expld.result.value = align_n (expld.dot, maxpage);
578 if (expld.dataseg.phase == exp_dataseg_relro_adjust)
579 expld.result.value = expld.dataseg.base;
580 else if (expld.dataseg.phase == exp_dataseg_adjust)
582 if (commonpage < maxpage)
583 expld.result.value += ((expld.dot + commonpage - 1)
584 & (maxpage - commonpage));
588 expld.result.value += expld.dot & (maxpage - 1);
589 if (expld.dataseg.phase == exp_dataseg_done)
593 else if (expld.dataseg.phase == exp_dataseg_none)
595 expld.dataseg.phase = exp_dataseg_align_seen;
596 expld.dataseg.base = expld.result.value;
597 expld.dataseg.pagesize = commonpage;
598 expld.dataseg.maxpagesize = maxpage;
599 expld.dataseg.relro_end = 0;
602 expld.result.valid_p = FALSE;
607 case DATA_SEGMENT_RELRO_END:
608 /* Operands swapped! DATA_SEGMENT_RELRO_END(offset,exp)
609 has offset in expld.result and exp in lhs. */
610 expld.dataseg.relro = exp_dataseg_relro_end;
611 expld.dataseg.relro_offset = expld.result.value;
612 if (expld.phase == lang_first_phase_enum
613 || expld.section != bfd_abs_section_ptr)
614 expld.result.valid_p = FALSE;
615 else if (expld.dataseg.phase == exp_dataseg_align_seen
616 || expld.dataseg.phase == exp_dataseg_adjust
617 || expld.dataseg.phase == exp_dataseg_relro_adjust
618 || expld.dataseg.phase == exp_dataseg_done)
620 if (expld.dataseg.phase == exp_dataseg_align_seen
621 || expld.dataseg.phase == exp_dataseg_relro_adjust)
622 expld.dataseg.relro_end = lhs.value + expld.result.value;
624 if (expld.dataseg.phase == exp_dataseg_relro_adjust
625 && (expld.dataseg.relro_end
626 & (expld.dataseg.pagesize - 1)))
628 expld.dataseg.relro_end += expld.dataseg.pagesize - 1;
629 expld.dataseg.relro_end &= ~(expld.dataseg.pagesize - 1);
630 expld.result.value = (expld.dataseg.relro_end
631 - expld.result.value);
634 expld.result.value = lhs.value;
636 if (expld.dataseg.phase == exp_dataseg_align_seen)
637 expld.dataseg.phase = exp_dataseg_relro_seen;
640 expld.result.valid_p = FALSE;
650 fold_trinary (etree_type *tree)
652 exp_fold_tree_1 (tree->trinary.cond);
653 if (expld.result.valid_p)
654 exp_fold_tree_1 (expld.result.value
656 : tree->trinary.rhs);
660 fold_name (etree_type *tree)
662 memset (&expld.result, 0, sizeof (expld.result));
664 switch (tree->type.node_code)
667 if (expld.phase != lang_first_phase_enum)
669 bfd_vma hdr_size = 0;
670 /* Don't find the real header size if only marking sections;
671 The bfd function may cache incorrect data. */
672 if (expld.phase != lang_mark_phase_enum)
673 hdr_size = bfd_sizeof_headers (link_info.output_bfd, &link_info);
674 new_number (hdr_size);
679 if (expld.phase != lang_first_phase_enum)
681 struct bfd_link_hash_entry *h;
682 struct definedness_hash_entry *def;
684 h = bfd_wrapped_link_hash_lookup (link_info.output_bfd,
688 new_number (h != NULL
689 && (h->type == bfd_link_hash_defined
690 || h->type == bfd_link_hash_defweak
691 || h->type == bfd_link_hash_common)
692 && ((def = symbol_defined (tree->name.name)) == NULL
694 || def->iteration == (lang_statement_iteration & 1)));
699 if (expld.assign_name != NULL
700 && strcmp (expld.assign_name, tree->name.name) == 0)
702 /* Self-assignment is only allowed for absolute symbols
703 defined in a linker script. */
704 struct bfd_link_hash_entry *h;
705 struct definedness_hash_entry *def;
707 h = bfd_wrapped_link_hash_lookup (link_info.output_bfd,
712 && (h->type == bfd_link_hash_defined
713 || h->type == bfd_link_hash_defweak)
714 && h->u.def.section == bfd_abs_section_ptr
715 && (def = symbol_defined (tree->name.name)) != NULL
716 && def->iteration == (lang_statement_iteration & 1)))
717 expld.assign_name = NULL;
719 if (expld.phase == lang_first_phase_enum)
721 else if (tree->name.name[0] == '.' && tree->name.name[1] == 0)
722 new_rel_from_abs (expld.dot);
725 struct bfd_link_hash_entry *h;
727 h = bfd_wrapped_link_hash_lookup (link_info.output_bfd,
732 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
733 else if (h->type == bfd_link_hash_defined
734 || h->type == bfd_link_hash_defweak)
736 asection *output_section;
738 output_section = h->u.def.section->output_section;
739 if (output_section == NULL)
741 if (expld.phase == lang_mark_phase_enum)
742 new_rel (h->u.def.value, h->u.def.section);
744 einfo (_("%X%S: unresolvable symbol `%s'"
745 " referenced in expression\n"),
746 tree, tree->name.name);
748 else if (output_section == bfd_abs_section_ptr
749 && (expld.section != bfd_abs_section_ptr
750 || config.sane_expr))
751 new_number (h->u.def.value + h->u.def.section->output_offset);
753 new_rel (h->u.def.value + h->u.def.section->output_offset,
756 else if (expld.phase == lang_final_phase_enum
757 || (expld.phase != lang_mark_phase_enum
758 && expld.assigning_to_dot))
759 einfo (_("%F%S: undefined symbol `%s'"
760 " referenced in expression\n"),
761 tree, tree->name.name);
762 else if (h->type == bfd_link_hash_new)
764 h->type = bfd_link_hash_undefined;
765 h->u.undef.abfd = NULL;
766 if (h->u.undef.next == NULL && h != link_info.hash->undefs_tail)
767 bfd_link_add_undef (link_info.hash, h);
773 if (expld.phase != lang_first_phase_enum)
775 lang_output_section_statement_type *os;
777 os = lang_output_section_find (tree->name.name);
780 if (expld.phase == lang_final_phase_enum)
781 einfo (_("%F%S: undefined section `%s'"
782 " referenced in expression\n"),
783 tree, tree->name.name);
785 else if (os->processed_vma)
786 new_rel (0, os->bfd_section);
791 if (expld.phase != lang_first_phase_enum)
793 lang_output_section_statement_type *os;
795 os = lang_output_section_find (tree->name.name);
798 if (expld.phase == lang_final_phase_enum)
799 einfo (_("%F%S: undefined section `%s'"
800 " referenced in expression\n"),
801 tree, tree->name.name);
803 else if (os->processed_lma)
805 if (os->load_base == NULL)
806 new_abs (os->bfd_section->lma);
809 exp_fold_tree_1 (os->load_base);
810 if (expld.result.valid_p)
819 if (expld.phase != lang_first_phase_enum)
821 lang_output_section_statement_type *os;
823 os = lang_output_section_find (tree->name.name);
826 if (expld.phase == lang_final_phase_enum)
827 einfo (_("%F%S: undefined section `%s'"
828 " referenced in expression\n"),
829 tree, tree->name.name);
832 else if (os->bfd_section != NULL)
836 if (tree->type.node_code == SIZEOF)
837 val = (os->bfd_section->size
838 / bfd_octets_per_byte (link_info.output_bfd));
840 val = (bfd_vma)1 << os->bfd_section->alignment_power;
851 if (expld.phase != lang_first_phase_enum)
853 lang_memory_region_type *mem;
855 mem = lang_memory_region_lookup (tree->name.name, FALSE);
857 new_number (mem->length);
859 einfo (_("%F%S: undefined MEMORY region `%s'"
860 " referenced in expression\n"),
861 tree, tree->name.name);
867 if (expld.phase != lang_first_phase_enum)
869 lang_memory_region_type *mem;
871 mem = lang_memory_region_lookup (tree->name.name, FALSE);
873 new_rel_from_abs (mem->origin);
875 einfo (_("%F%S: undefined MEMORY region `%s'"
876 " referenced in expression\n"),
877 tree, tree->name.name);
882 if (strcmp (tree->name.name, "MAXPAGESIZE") == 0)
883 new_number (config.maxpagesize);
884 else if (strcmp (tree->name.name, "COMMONPAGESIZE") == 0)
885 new_number (config.commonpagesize);
887 einfo (_("%F%S: unknown constant `%s' referenced in expression\n"),
888 tree, tree->name.name);
897 /* Return true if TREE is '.'. */
900 is_dot (const etree_type *tree)
902 return (tree->type.node_class == etree_name
903 && tree->type.node_code == NAME
904 && tree->name.name[0] == '.'
905 && tree->name.name[1] == 0);
908 /* Return true if TREE is a constant equal to VAL. */
911 is_value (const etree_type *tree, bfd_vma val)
913 return (tree->type.node_class == etree_value
914 && tree->value.value == val);
917 /* Return true if TREE is an absolute symbol equal to VAL defined in
921 is_sym_value (const etree_type *tree, bfd_vma val)
923 struct bfd_link_hash_entry *h;
924 struct definedness_hash_entry *def;
926 return (tree->type.node_class == etree_name
927 && tree->type.node_code == NAME
928 && (def = symbol_defined (tree->name.name)) != NULL
930 && def->iteration == (lang_statement_iteration & 1)
931 && (h = bfd_wrapped_link_hash_lookup (link_info.output_bfd,
934 FALSE, FALSE, TRUE)) != NULL
935 && h->type == bfd_link_hash_defined
936 && h->u.def.section == bfd_abs_section_ptr
937 && h->u.def.value == val);
940 /* Return true if TREE is ". != 0". */
943 is_dot_ne_0 (const etree_type *tree)
945 return (tree->type.node_class == etree_binary
946 && tree->type.node_code == NE
947 && is_dot (tree->binary.lhs)
948 && is_value (tree->binary.rhs, 0));
951 /* Return true if TREE is ". = . + 0" or ". = . + sym" where sym is an
952 absolute constant with value 0 defined in a linker script. */
955 is_dot_plus_0 (const etree_type *tree)
957 return (tree->type.node_class == etree_binary
958 && tree->type.node_code == '+'
959 && is_dot (tree->binary.lhs)
960 && (is_value (tree->binary.rhs, 0)
961 || is_sym_value (tree->binary.rhs, 0)));
964 /* Return true if TREE is "ALIGN (. != 0 ? some_expression : 1)". */
967 is_align_conditional (const etree_type *tree)
969 if (tree->type.node_class == etree_unary
970 && tree->type.node_code == ALIGN_K)
972 tree = tree->unary.child;
973 return (tree->type.node_class == etree_trinary
974 && is_dot_ne_0 (tree->trinary.cond)
975 && is_value (tree->trinary.rhs, 1));
980 /* Subroutine of exp_fold_tree_1 for copying a symbol type. */
983 try_copy_symbol_type (struct bfd_link_hash_entry *h, etree_type *src)
985 if (src->type.node_class == etree_name)
987 struct bfd_link_hash_entry *hsrc;
989 hsrc = bfd_link_hash_lookup (link_info.hash, src->name.name,
992 bfd_copy_link_hash_symbol_type (link_info.output_bfd, h,
998 exp_fold_tree_1 (etree_type *tree)
1002 memset (&expld.result, 0, sizeof (expld.result));
1006 switch (tree->type.node_class)
1009 if (expld.section == bfd_abs_section_ptr
1010 && !config.sane_expr)
1011 new_abs (tree->value.value);
1013 new_number (tree->value.value);
1014 expld.result.str = tree->value.str;
1018 if (expld.phase != lang_first_phase_enum)
1020 asection *output_section = tree->rel.section->output_section;
1021 new_rel (tree->rel.value + tree->rel.section->output_offset,
1025 memset (&expld.result, 0, sizeof (expld.result));
1029 exp_fold_tree_1 (tree->assert_s.child);
1030 if (expld.phase == lang_final_phase_enum && !expld.result.value)
1031 einfo ("%X%P: %s\n", tree->assert_s.message);
1043 fold_trinary (tree);
1048 case etree_provided:
1049 if (tree->assign.dst[0] == '.' && tree->assign.dst[1] == 0)
1051 if (tree->type.node_class != etree_assign)
1052 einfo (_("%F%S can not PROVIDE assignment to"
1053 " location counter\n"), tree);
1054 if (expld.phase != lang_first_phase_enum)
1056 /* Notify the folder that this is an assignment to dot. */
1057 expld.assigning_to_dot = TRUE;
1058 exp_fold_tree_1 (tree->assign.src);
1059 expld.assigning_to_dot = FALSE;
1061 /* If we are assigning to dot inside an output section
1062 arrange to keep the section, except for certain
1063 expressions that evaluate to zero. We ignore . = 0,
1064 . = . + 0, and . = ALIGN (. != 0 ? expr : 1).
1065 We can't ignore all expressions that evaluate to zero
1066 because an otherwise empty section might have padding
1067 added by an alignment expression that changes with
1068 relaxation. Such a section might have zero size
1069 before relaxation and so be stripped incorrectly. */
1070 if (expld.phase == lang_mark_phase_enum
1071 && expld.section != bfd_abs_section_ptr
1072 && !(expld.result.valid_p
1073 && expld.result.value == 0
1074 && (is_value (tree->assign.src, 0)
1075 || is_sym_value (tree->assign.src, 0)
1076 || is_dot_plus_0 (tree->assign.src)
1077 || is_align_conditional (tree->assign.src))))
1078 expld.section->flags |= SEC_KEEP;
1080 if (!expld.result.valid_p)
1082 if (expld.phase != lang_mark_phase_enum)
1083 einfo (_("%F%S invalid assignment to"
1084 " location counter\n"), tree);
1086 else if (expld.dotp == NULL)
1087 einfo (_("%F%S assignment to location counter"
1088 " invalid outside of SECTIONS\n"), tree);
1090 /* After allocation, assignment to dot should not be
1091 done inside an output section since allocation adds a
1092 padding statement that effectively duplicates the
1094 else if (expld.phase <= lang_allocating_phase_enum
1095 || expld.section == bfd_abs_section_ptr)
1099 nextdot = expld.result.value;
1100 if (expld.result.section != NULL)
1101 nextdot += expld.result.section->vma;
1103 nextdot += expld.section->vma;
1104 if (nextdot < expld.dot
1105 && expld.section != bfd_abs_section_ptr)
1106 einfo (_("%F%S cannot move location counter backwards"
1107 " (from %V to %V)\n"),
1108 tree, expld.dot, nextdot);
1111 expld.dot = nextdot;
1112 *expld.dotp = nextdot;
1117 memset (&expld.result, 0, sizeof (expld.result));
1121 struct bfd_link_hash_entry *h = NULL;
1123 if (tree->type.node_class == etree_provide)
1125 h = bfd_link_hash_lookup (link_info.hash, tree->assign.dst,
1126 FALSE, FALSE, TRUE);
1128 || !(h->type == bfd_link_hash_new
1129 || h->type == bfd_link_hash_undefined
1130 || h->type == bfd_link_hash_undefweak
1133 /* Do nothing. The symbol was never referenced, or
1134 was defined in some object file. Note that
1135 undefweak symbols are defined by PROVIDE. This
1136 is to support glibc use of __rela_iplt_start and
1137 similar weak references. */
1142 expld.assign_name = tree->assign.dst;
1143 exp_fold_tree_1 (tree->assign.src);
1144 /* expld.assign_name remaining equal to tree->assign.dst
1145 below indicates the evaluation of tree->assign.src did
1146 not use the value of tree->assign.dst. We don't allow
1147 self assignment until the final phase for two reasons:
1148 1) Expressions are evaluated multiple times. With
1149 relaxation, the number of times may vary.
1150 2) Section relative symbol values cannot be correctly
1151 converted to absolute values, as is required by many
1152 expressions, until final section sizing is complete. */
1153 if ((expld.result.valid_p
1154 && (expld.phase == lang_final_phase_enum
1155 || expld.assign_name != NULL))
1156 || (expld.phase <= lang_mark_phase_enum
1157 && tree->type.node_class == etree_assign
1158 && tree->assign.defsym))
1162 h = bfd_link_hash_lookup (link_info.hash, tree->assign.dst,
1165 einfo (_("%P%F:%s: hash creation failed\n"),
1169 if (expld.result.section == NULL)
1170 expld.result.section = expld.section;
1171 if (!update_definedness (tree->assign.dst, h) && 0)
1173 /* Symbol was already defined. For now this error
1174 is disabled because it causes failures in the ld
1175 testsuite: ld-elf/var1, ld-scripts/defined5, and
1176 ld-scripts/pr14962. Some of these no doubt
1177 reflect scripts used in the wild. */
1178 (*link_info.callbacks->multiple_definition)
1179 (&link_info, h, link_info.output_bfd,
1180 expld.result.section, expld.result.value);
1182 h->type = bfd_link_hash_defined;
1183 h->u.def.value = expld.result.value;
1184 h->u.def.section = expld.result.section;
1185 h->linker_def = ! tree->assign.type.lineno;
1186 if (tree->type.node_class == etree_provide)
1187 tree->type.node_class = etree_provided;
1189 /* Copy the symbol type if this is a simple assignment of
1190 one symbol to another. Also, handle the case of a foldable
1191 ternary conditional with names on either side. */
1192 if (tree->assign.src->type.node_class == etree_name)
1193 try_copy_symbol_type (h, tree->assign.src);
1194 else if (tree->assign.src->type.node_class == etree_trinary)
1196 exp_fold_tree_1 (tree->assign.src->trinary.cond);
1197 if (expld.result.valid_p)
1199 if (expld.result.value
1200 && tree->assign.src->trinary.lhs->type.node_class
1202 try_copy_symbol_type (h, tree->assign.src->trinary.lhs);
1204 if (!expld.result.value
1205 && tree->assign.src->trinary.rhs->type.node_class
1207 try_copy_symbol_type (h, tree->assign.src->trinary.rhs);
1211 else if (expld.phase == lang_final_phase_enum)
1213 h = bfd_link_hash_lookup (link_info.hash, tree->assign.dst,
1214 FALSE, FALSE, TRUE);
1216 && h->type == bfd_link_hash_new)
1217 h->type = bfd_link_hash_undefined;
1219 expld.assign_name = NULL;
1229 memset (&expld.result, 0, sizeof (expld.result));
1235 exp_fold_tree (etree_type *tree, asection *current_section, bfd_vma *dotp)
1237 expld.rel_from_abs = FALSE;
1240 expld.section = current_section;
1241 exp_fold_tree_1 (tree);
1245 exp_fold_tree_no_dot (etree_type *tree)
1247 expld.rel_from_abs = FALSE;
1250 expld.section = bfd_abs_section_ptr;
1251 exp_fold_tree_1 (tree);
1255 exp_binop (int code, etree_type *lhs, etree_type *rhs)
1257 etree_type value, *new_e;
1259 value.type.node_code = code;
1260 value.type.filename = lhs->type.filename;
1261 value.type.lineno = lhs->type.lineno;
1262 value.binary.lhs = lhs;
1263 value.binary.rhs = rhs;
1264 value.type.node_class = etree_binary;
1265 exp_fold_tree_no_dot (&value);
1266 if (expld.result.valid_p)
1267 return exp_intop (expld.result.value);
1269 new_e = (etree_type *) stat_alloc (sizeof (new_e->binary));
1270 memcpy (new_e, &value, sizeof (new_e->binary));
1275 exp_trinop (int code, etree_type *cond, etree_type *lhs, etree_type *rhs)
1277 etree_type value, *new_e;
1279 value.type.node_code = code;
1280 value.type.filename = cond->type.filename;
1281 value.type.lineno = cond->type.lineno;
1282 value.trinary.lhs = lhs;
1283 value.trinary.cond = cond;
1284 value.trinary.rhs = rhs;
1285 value.type.node_class = etree_trinary;
1286 exp_fold_tree_no_dot (&value);
1287 if (expld.result.valid_p)
1288 return exp_intop (expld.result.value);
1290 new_e = (etree_type *) stat_alloc (sizeof (new_e->trinary));
1291 memcpy (new_e, &value, sizeof (new_e->trinary));
1296 exp_unop (int code, etree_type *child)
1298 etree_type value, *new_e;
1300 value.unary.type.node_code = code;
1301 value.unary.type.filename = child->type.filename;
1302 value.unary.type.lineno = child->type.lineno;
1303 value.unary.child = child;
1304 value.unary.type.node_class = etree_unary;
1305 exp_fold_tree_no_dot (&value);
1306 if (expld.result.valid_p)
1307 return exp_intop (expld.result.value);
1309 new_e = (etree_type *) stat_alloc (sizeof (new_e->unary));
1310 memcpy (new_e, &value, sizeof (new_e->unary));
1315 exp_nameop (int code, const char *name)
1317 etree_type value, *new_e;
1319 value.name.type.node_code = code;
1320 value.name.type.filename = ldlex_filename ();
1321 value.name.type.lineno = lineno;
1322 value.name.name = name;
1323 value.name.type.node_class = etree_name;
1325 exp_fold_tree_no_dot (&value);
1326 if (expld.result.valid_p)
1327 return exp_intop (expld.result.value);
1329 new_e = (etree_type *) stat_alloc (sizeof (new_e->name));
1330 memcpy (new_e, &value, sizeof (new_e->name));
1336 exp_assop (const char *dst,
1338 enum node_tree_enum class,
1344 n = (etree_type *) stat_alloc (sizeof (n->assign));
1345 n->assign.type.node_code = '=';
1346 n->assign.type.filename = src->type.filename;
1347 n->assign.type.lineno = src->type.lineno;
1348 n->assign.type.node_class = class;
1349 n->assign.src = src;
1350 n->assign.dst = dst;
1351 n->assign.defsym = defsym;
1352 n->assign.hidden = hidden;
1356 /* Handle linker script assignments and HIDDEN. */
1359 exp_assign (const char *dst, etree_type *src, bfd_boolean hidden)
1361 return exp_assop (dst, src, etree_assign, FALSE, hidden);
1364 /* Handle --defsym command-line option. */
1367 exp_defsym (const char *dst, etree_type *src)
1369 return exp_assop (dst, src, etree_assign, TRUE, FALSE);
1372 /* Handle PROVIDE. */
1375 exp_provide (const char *dst, etree_type *src, bfd_boolean hidden)
1377 return exp_assop (dst, src, etree_provide, FALSE, hidden);
1380 /* Handle ASSERT. */
1383 exp_assert (etree_type *exp, const char *message)
1387 n = (etree_type *) stat_alloc (sizeof (n->assert_s));
1388 n->assert_s.type.node_code = '!';
1389 n->assert_s.type.filename = exp->type.filename;
1390 n->assert_s.type.lineno = exp->type.lineno;
1391 n->assert_s.type.node_class = etree_assert;
1392 n->assert_s.child = exp;
1393 n->assert_s.message = message;
1398 exp_print_tree (etree_type *tree)
1400 bfd_boolean function_like;
1402 if (config.map_file == NULL)
1403 config.map_file = stderr;
1407 minfo ("NULL TREE\n");
1411 switch (tree->type.node_class)
1414 minfo ("0x%v", tree->value.value);
1417 if (tree->rel.section->owner != NULL)
1418 minfo ("%B:", tree->rel.section->owner);
1419 minfo ("%s+0x%v", tree->rel.section->name, tree->rel.value);
1422 fputs (tree->assign.dst, config.map_file);
1423 exp_print_token (tree->type.node_code, TRUE);
1424 exp_print_tree (tree->assign.src);
1427 case etree_provided:
1428 fprintf (config.map_file, "PROVIDE (%s, ", tree->assign.dst);
1429 exp_print_tree (tree->assign.src);
1430 fputc (')', config.map_file);
1433 function_like = FALSE;
1434 switch (tree->type.node_code)
1439 case DATA_SEGMENT_ALIGN:
1440 case DATA_SEGMENT_RELRO_END:
1441 function_like = TRUE;
1444 /* Special handling because arguments are in reverse order and
1445 the segment name is quoted. */
1446 exp_print_token (tree->type.node_code, FALSE);
1447 fputs (" (\"", config.map_file);
1448 exp_print_tree (tree->binary.rhs);
1449 fputs ("\", ", config.map_file);
1450 exp_print_tree (tree->binary.lhs);
1451 fputc (')', config.map_file);
1456 exp_print_token (tree->type.node_code, FALSE);
1457 fputc (' ', config.map_file);
1459 fputc ('(', config.map_file);
1460 exp_print_tree (tree->binary.lhs);
1462 fprintf (config.map_file, ", ");
1464 exp_print_token (tree->type.node_code, TRUE);
1465 exp_print_tree (tree->binary.rhs);
1466 fputc (')', config.map_file);
1469 exp_print_tree (tree->trinary.cond);
1470 fputc ('?', config.map_file);
1471 exp_print_tree (tree->trinary.lhs);
1472 fputc (':', config.map_file);
1473 exp_print_tree (tree->trinary.rhs);
1476 exp_print_token (tree->unary.type.node_code, FALSE);
1477 if (tree->unary.child)
1479 fprintf (config.map_file, " (");
1480 exp_print_tree (tree->unary.child);
1481 fputc (')', config.map_file);
1486 fprintf (config.map_file, "ASSERT (");
1487 exp_print_tree (tree->assert_s.child);
1488 fprintf (config.map_file, ", %s)", tree->assert_s.message);
1492 if (tree->type.node_code == NAME)
1493 fputs (tree->name.name, config.map_file);
1496 exp_print_token (tree->type.node_code, FALSE);
1497 if (tree->name.name)
1498 fprintf (config.map_file, " (%s)", tree->name.name);
1508 exp_get_vma (etree_type *tree, bfd_vma def, char *name)
1512 exp_fold_tree_no_dot (tree);
1513 if (expld.result.valid_p)
1514 return expld.result.value;
1515 else if (name != NULL && expld.phase != lang_mark_phase_enum)
1516 einfo (_("%F%S: nonconstant expression for %s\n"),
1523 exp_get_value_int (etree_type *tree, int def, char *name)
1525 return exp_get_vma (tree, def, name);
1529 exp_get_fill (etree_type *tree, fill_type *def, char *name)
1538 exp_fold_tree_no_dot (tree);
1539 if (!expld.result.valid_p)
1541 if (name != NULL && expld.phase != lang_mark_phase_enum)
1542 einfo (_("%F%S: nonconstant expression for %s\n"),
1547 if (expld.result.str != NULL && (len = strlen (expld.result.str)) != 0)
1551 fill = (fill_type *) xmalloc ((len + 1) / 2 + sizeof (*fill) - 1);
1552 fill->size = (len + 1) / 2;
1554 s = (unsigned char *) expld.result.str;
1562 digit = (digit - 'A' + '0' + 10) & 0xf;
1576 fill = (fill_type *) xmalloc (4 + sizeof (*fill) - 1);
1577 val = expld.result.value;
1578 fill->data[0] = (val >> 24) & 0xff;
1579 fill->data[1] = (val >> 16) & 0xff;
1580 fill->data[2] = (val >> 8) & 0xff;
1581 fill->data[3] = (val >> 0) & 0xff;
1588 exp_get_abs_int (etree_type *tree, int def, char *name)
1592 exp_fold_tree_no_dot (tree);
1594 if (expld.result.valid_p)
1596 if (expld.result.section != NULL)
1597 expld.result.value += expld.result.section->vma;
1598 return expld.result.value;
1600 else if (name != NULL && expld.phase != lang_mark_phase_enum)
1602 einfo (_("%F%S: nonconstant expression for %s\n"),
1610 align_n (bfd_vma value, bfd_vma align)
1615 value = (value + align - 1) / align;
1616 return value * align;
1622 /* The value "13" is ad-hoc, somewhat related to the expected number of
1623 assignments in a linker script. */
1624 if (!bfd_hash_table_init_n (&definedness_table,
1625 definedness_newfunc,
1626 sizeof (struct definedness_hash_entry),
1628 einfo (_("%P%F: can not create hash table: %E\n"));
1631 /* Convert absolute symbols defined by a script from "dot" (also
1632 SEGMENT_START or ORIGIN) outside of an output section statement,
1633 to section relative. */
1636 set_sym_sections (struct bfd_hash_entry *bh, void *inf ATTRIBUTE_UNUSED)
1638 struct definedness_hash_entry *def = (struct definedness_hash_entry *) bh;
1639 if (def->final_sec != bfd_abs_section_ptr)
1641 struct bfd_link_hash_entry *h;
1642 h = bfd_link_hash_lookup (link_info.hash, bh->string,
1643 FALSE, FALSE, TRUE);
1645 && h->type == bfd_link_hash_defined
1646 && h->u.def.section == bfd_abs_section_ptr)
1648 h->u.def.value -= def->final_sec->vma;
1649 h->u.def.section = def->final_sec;
1656 ldexp_finalize_syms (void)
1658 bfd_hash_traverse (&definedness_table, set_sym_sections, NULL);
1664 bfd_hash_table_free (&definedness_table);