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 h
->ldscript_def
= 1;
1187 if (tree
->type
.node_class
== etree_provide
)
1188 tree
->type
.node_class
= etree_provided
;
1190 /* Copy the symbol type if this is a simple assignment of
1191 one symbol to another. Also, handle the case of a foldable
1192 ternary conditional with names on either side. */
1193 if (tree
->assign
.src
->type
.node_class
== etree_name
)
1194 try_copy_symbol_type (h
, tree
->assign
.src
);
1195 else if (tree
->assign
.src
->type
.node_class
== etree_trinary
)
1197 exp_fold_tree_1 (tree
->assign
.src
->trinary
.cond
);
1198 if (expld
.result
.valid_p
)
1200 if (expld
.result
.value
1201 && tree
->assign
.src
->trinary
.lhs
->type
.node_class
1203 try_copy_symbol_type (h
, tree
->assign
.src
->trinary
.lhs
);
1205 if (!expld
.result
.value
1206 && tree
->assign
.src
->trinary
.rhs
->type
.node_class
1208 try_copy_symbol_type (h
, tree
->assign
.src
->trinary
.rhs
);
1212 else if (expld
.phase
== lang_final_phase_enum
)
1214 h
= bfd_link_hash_lookup (link_info
.hash
, tree
->assign
.dst
,
1215 FALSE
, FALSE
, TRUE
);
1217 && h
->type
== bfd_link_hash_new
)
1218 h
->type
= bfd_link_hash_undefined
;
1220 expld
.assign_name
= NULL
;
1230 memset (&expld
.result
, 0, sizeof (expld
.result
));
1236 exp_fold_tree (etree_type
*tree
, asection
*current_section
, bfd_vma
*dotp
)
1238 expld
.rel_from_abs
= FALSE
;
1241 expld
.section
= current_section
;
1242 exp_fold_tree_1 (tree
);
1246 exp_fold_tree_no_dot (etree_type
*tree
)
1248 expld
.rel_from_abs
= FALSE
;
1251 expld
.section
= bfd_abs_section_ptr
;
1252 exp_fold_tree_1 (tree
);
1256 exp_binop (int code
, etree_type
*lhs
, etree_type
*rhs
)
1258 etree_type
*new_e
= (etree_type
*) stat_alloc (sizeof (new_e
->binary
));
1260 new_e
->type
.node_code
= code
;
1261 new_e
->type
.filename
= lhs
->type
.filename
;
1262 new_e
->type
.lineno
= lhs
->type
.lineno
;
1263 new_e
->binary
.lhs
= lhs
;
1264 new_e
->binary
.rhs
= rhs
;
1265 new_e
->type
.node_class
= etree_binary
;
1270 exp_trinop (int code
, etree_type
*cond
, etree_type
*lhs
, etree_type
*rhs
)
1272 etree_type
*new_e
= (etree_type
*) stat_alloc (sizeof (new_e
->trinary
));
1274 new_e
->type
.node_code
= code
;
1275 new_e
->type
.filename
= cond
->type
.filename
;
1276 new_e
->type
.lineno
= cond
->type
.lineno
;
1277 new_e
->trinary
.lhs
= lhs
;
1278 new_e
->trinary
.cond
= cond
;
1279 new_e
->trinary
.rhs
= rhs
;
1280 new_e
->type
.node_class
= etree_trinary
;
1285 exp_unop (int code
, etree_type
*child
)
1287 etree_type
*new_e
= (etree_type
*) stat_alloc (sizeof (new_e
->unary
));
1289 new_e
->unary
.type
.node_code
= code
;
1290 new_e
->unary
.type
.filename
= child
->type
.filename
;
1291 new_e
->unary
.type
.lineno
= child
->type
.lineno
;
1292 new_e
->unary
.child
= child
;
1293 new_e
->unary
.type
.node_class
= etree_unary
;
1298 exp_nameop (int code
, const char *name
)
1300 etree_type
*new_e
= (etree_type
*) stat_alloc (sizeof (new_e
->name
));
1302 new_e
->name
.type
.node_code
= code
;
1303 new_e
->name
.type
.filename
= ldlex_filename ();
1304 new_e
->name
.type
.lineno
= lineno
;
1305 new_e
->name
.name
= name
;
1306 new_e
->name
.type
.node_class
= etree_name
;
1312 exp_assop (const char *dst
,
1314 enum node_tree_enum
class,
1320 n
= (etree_type
*) stat_alloc (sizeof (n
->assign
));
1321 n
->assign
.type
.node_code
= '=';
1322 n
->assign
.type
.filename
= src
->type
.filename
;
1323 n
->assign
.type
.lineno
= src
->type
.lineno
;
1324 n
->assign
.type
.node_class
= class;
1325 n
->assign
.src
= src
;
1326 n
->assign
.dst
= dst
;
1327 n
->assign
.defsym
= defsym
;
1328 n
->assign
.hidden
= hidden
;
1332 /* Handle linker script assignments and HIDDEN. */
1335 exp_assign (const char *dst
, etree_type
*src
, bfd_boolean hidden
)
1337 return exp_assop (dst
, src
, etree_assign
, FALSE
, hidden
);
1340 /* Handle --defsym command-line option. */
1343 exp_defsym (const char *dst
, etree_type
*src
)
1345 return exp_assop (dst
, src
, etree_assign
, TRUE
, FALSE
);
1348 /* Handle PROVIDE. */
1351 exp_provide (const char *dst
, etree_type
*src
, bfd_boolean hidden
)
1353 return exp_assop (dst
, src
, etree_provide
, FALSE
, hidden
);
1356 /* Handle ASSERT. */
1359 exp_assert (etree_type
*exp
, const char *message
)
1363 n
= (etree_type
*) stat_alloc (sizeof (n
->assert_s
));
1364 n
->assert_s
.type
.node_code
= '!';
1365 n
->assert_s
.type
.filename
= exp
->type
.filename
;
1366 n
->assert_s
.type
.lineno
= exp
->type
.lineno
;
1367 n
->assert_s
.type
.node_class
= etree_assert
;
1368 n
->assert_s
.child
= exp
;
1369 n
->assert_s
.message
= message
;
1374 exp_print_tree (etree_type
*tree
)
1376 bfd_boolean function_like
;
1378 if (config
.map_file
== NULL
)
1379 config
.map_file
= stderr
;
1383 minfo ("NULL TREE\n");
1387 switch (tree
->type
.node_class
)
1390 minfo ("0x%v", tree
->value
.value
);
1393 if (tree
->rel
.section
->owner
!= NULL
)
1394 minfo ("%B:", tree
->rel
.section
->owner
);
1395 minfo ("%s+0x%v", tree
->rel
.section
->name
, tree
->rel
.value
);
1398 fputs (tree
->assign
.dst
, config
.map_file
);
1399 exp_print_token (tree
->type
.node_code
, TRUE
);
1400 exp_print_tree (tree
->assign
.src
);
1403 case etree_provided
:
1404 fprintf (config
.map_file
, "PROVIDE (%s, ", tree
->assign
.dst
);
1405 exp_print_tree (tree
->assign
.src
);
1406 fputc (')', config
.map_file
);
1409 function_like
= FALSE
;
1410 switch (tree
->type
.node_code
)
1415 case DATA_SEGMENT_ALIGN
:
1416 case DATA_SEGMENT_RELRO_END
:
1417 function_like
= TRUE
;
1420 /* Special handling because arguments are in reverse order and
1421 the segment name is quoted. */
1422 exp_print_token (tree
->type
.node_code
, FALSE
);
1423 fputs (" (\"", config
.map_file
);
1424 exp_print_tree (tree
->binary
.rhs
);
1425 fputs ("\", ", config
.map_file
);
1426 exp_print_tree (tree
->binary
.lhs
);
1427 fputc (')', config
.map_file
);
1432 exp_print_token (tree
->type
.node_code
, FALSE
);
1433 fputc (' ', config
.map_file
);
1435 fputc ('(', config
.map_file
);
1436 exp_print_tree (tree
->binary
.lhs
);
1438 fprintf (config
.map_file
, ", ");
1440 exp_print_token (tree
->type
.node_code
, TRUE
);
1441 exp_print_tree (tree
->binary
.rhs
);
1442 fputc (')', config
.map_file
);
1445 exp_print_tree (tree
->trinary
.cond
);
1446 fputc ('?', config
.map_file
);
1447 exp_print_tree (tree
->trinary
.lhs
);
1448 fputc (':', config
.map_file
);
1449 exp_print_tree (tree
->trinary
.rhs
);
1452 exp_print_token (tree
->unary
.type
.node_code
, FALSE
);
1453 if (tree
->unary
.child
)
1455 fprintf (config
.map_file
, " (");
1456 exp_print_tree (tree
->unary
.child
);
1457 fputc (')', config
.map_file
);
1462 fprintf (config
.map_file
, "ASSERT (");
1463 exp_print_tree (tree
->assert_s
.child
);
1464 fprintf (config
.map_file
, ", %s)", tree
->assert_s
.message
);
1468 if (tree
->type
.node_code
== NAME
)
1469 fputs (tree
->name
.name
, config
.map_file
);
1472 exp_print_token (tree
->type
.node_code
, FALSE
);
1473 if (tree
->name
.name
)
1474 fprintf (config
.map_file
, " (%s)", tree
->name
.name
);
1484 exp_get_vma (etree_type
*tree
, bfd_vma def
, char *name
)
1488 exp_fold_tree_no_dot (tree
);
1489 if (expld
.result
.valid_p
)
1490 return expld
.result
.value
;
1491 else if (name
!= NULL
&& expld
.phase
!= lang_mark_phase_enum
)
1492 einfo (_("%F%S: nonconstant expression for %s\n"),
1499 exp_get_value_int (etree_type
*tree
, int def
, char *name
)
1501 return exp_get_vma (tree
, def
, name
);
1505 exp_get_fill (etree_type
*tree
, fill_type
*def
, char *name
)
1514 exp_fold_tree_no_dot (tree
);
1515 if (!expld
.result
.valid_p
)
1517 if (name
!= NULL
&& expld
.phase
!= lang_mark_phase_enum
)
1518 einfo (_("%F%S: nonconstant expression for %s\n"),
1523 if (expld
.result
.str
!= NULL
&& (len
= strlen (expld
.result
.str
)) != 0)
1527 fill
= (fill_type
*) xmalloc ((len
+ 1) / 2 + sizeof (*fill
) - 1);
1528 fill
->size
= (len
+ 1) / 2;
1530 s
= (unsigned char *) expld
.result
.str
;
1538 digit
= (digit
- 'A' + '0' + 10) & 0xf;
1552 fill
= (fill_type
*) xmalloc (4 + sizeof (*fill
) - 1);
1553 val
= expld
.result
.value
;
1554 fill
->data
[0] = (val
>> 24) & 0xff;
1555 fill
->data
[1] = (val
>> 16) & 0xff;
1556 fill
->data
[2] = (val
>> 8) & 0xff;
1557 fill
->data
[3] = (val
>> 0) & 0xff;
1564 exp_get_abs_int (etree_type
*tree
, int def
, char *name
)
1568 exp_fold_tree_no_dot (tree
);
1570 if (expld
.result
.valid_p
)
1572 if (expld
.result
.section
!= NULL
)
1573 expld
.result
.value
+= expld
.result
.section
->vma
;
1574 return expld
.result
.value
;
1576 else if (name
!= NULL
&& expld
.phase
!= lang_mark_phase_enum
)
1578 einfo (_("%F%S: nonconstant expression for %s\n"),
1586 align_n (bfd_vma value
, bfd_vma align
)
1591 value
= (value
+ align
- 1) / align
;
1592 return value
* align
;
1598 /* The value "13" is ad-hoc, somewhat related to the expected number of
1599 assignments in a linker script. */
1600 if (!bfd_hash_table_init_n (&definedness_table
,
1601 definedness_newfunc
,
1602 sizeof (struct definedness_hash_entry
),
1604 einfo (_("%P%F: can not create hash table: %E\n"));
1607 /* Convert absolute symbols defined by a script from "dot" (also
1608 SEGMENT_START or ORIGIN) outside of an output section statement,
1609 to section relative. */
1612 set_sym_sections (struct bfd_hash_entry
*bh
, void *inf ATTRIBUTE_UNUSED
)
1614 struct definedness_hash_entry
*def
= (struct definedness_hash_entry
*) bh
;
1615 if (def
->final_sec
!= bfd_abs_section_ptr
)
1617 struct bfd_link_hash_entry
*h
;
1618 h
= bfd_link_hash_lookup (link_info
.hash
, bh
->string
,
1619 FALSE
, FALSE
, TRUE
);
1621 && h
->type
== bfd_link_hash_defined
1622 && h
->u
.def
.section
== bfd_abs_section_ptr
)
1624 h
->u
.def
.value
-= def
->final_sec
->vma
;
1625 h
->u
.def
.section
= def
->final_sec
;
1632 ldexp_finalize_syms (void)
1634 bfd_hash_traverse (&definedness_table
, set_sym_sections
, NULL
);
1640 bfd_hash_table_free (&definedness_table
);