1 /* This module handles expression trees.
2 Copyright (C) 1991-2019 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
42 #include "libiberty.h"
43 #include "safe-ctype.h"
45 static void exp_fold_tree_1 (etree_type
*);
46 static bfd_vma
align_n (bfd_vma
, bfd_vma
);
48 segment_type
*segments
;
50 struct ldexp_control expld
;
52 /* This structure records symbols for which we need to keep track of
53 definedness for use in the DEFINED () test. It is also used in
54 making absolute symbols section relative late in the link. */
56 struct definedness_hash_entry
58 struct bfd_hash_entry root
;
60 /* If this symbol was assigned from "dot" outside of an output
61 section statement, the section we'd like it relative to. */
64 /* Low bits of iteration count. Symbols with matching iteration have
65 been defined in this pass over the script. */
66 unsigned int iteration
: 8;
68 /* Symbol was defined by an object file. */
69 unsigned int by_object
: 1;
72 static struct bfd_hash_table definedness_table
;
74 /* Print the string representation of the given token. Surround it
75 with spaces if INFIX_P is TRUE. */
78 exp_print_token (token_code_type code
, int infix_p
)
105 { LOG2CEIL
, "LOG2CEIL" },
106 { ALIGN_K
, "ALIGN" },
113 { SECTIONS
, "SECTIONS" },
114 { SIZEOF_HEADERS
, "SIZEOF_HEADERS" },
115 { MEMORY
, "MEMORY" },
116 { DEFINED
, "DEFINED" },
117 { TARGET_K
, "TARGET" },
118 { SEARCH_DIR
, "SEARCH_DIR" },
122 { ALIGNOF
, "ALIGNOF" },
123 { SIZEOF
, "SIZEOF" },
125 { LOADADDR
, "LOADADDR" },
126 { CONSTANT
, "CONSTANT" },
127 { ABSOLUTE
, "ABSOLUTE" },
130 { ASSERT_K
, "ASSERT" },
131 { REL
, "relocatable" },
132 { DATA_SEGMENT_ALIGN
, "DATA_SEGMENT_ALIGN" },
133 { DATA_SEGMENT_RELRO_END
, "DATA_SEGMENT_RELRO_END" },
134 { DATA_SEGMENT_END
, "DATA_SEGMENT_END" },
135 { ORIGIN
, "ORIGIN" },
136 { LENGTH
, "LENGTH" },
137 { SEGMENT_START
, "SEGMENT_START" }
141 for (idx
= 0; idx
< ARRAY_SIZE (table
); idx
++)
142 if (table
[idx
].code
== code
)
146 fputc (' ', config
.map_file
);
148 if (idx
< ARRAY_SIZE (table
))
149 fputs (table
[idx
].name
, config
.map_file
);
151 fputc (code
, config
.map_file
);
153 fprintf (config
.map_file
, "<code %d>", code
);
156 fputc (' ', config
.map_file
);
162 bfd_vma value
= expld
.result
.value
;
164 bfd_boolean round_up
= FALSE
;
169 /* If more than one bit is set in the value we will need to round up. */
170 if ((value
> 1) && (value
& 1))
177 expld
.result
.section
= NULL
;
178 expld
.result
.value
= result
;
184 if (expld
.result
.section
!= NULL
)
185 expld
.result
.value
+= expld
.result
.section
->vma
;
186 expld
.result
.section
= bfd_abs_section_ptr
;
187 expld
.rel_from_abs
= FALSE
;
191 new_abs (bfd_vma value
)
193 expld
.result
.valid_p
= TRUE
;
194 expld
.result
.section
= bfd_abs_section_ptr
;
195 expld
.result
.value
= value
;
196 expld
.result
.str
= NULL
;
200 exp_intop (bfd_vma value
)
202 etree_type
*new_e
= stat_alloc (sizeof (new_e
->value
));
203 new_e
->type
.node_code
= INT
;
204 new_e
->type
.filename
= ldlex_filename ();
205 new_e
->type
.lineno
= lineno
;
206 new_e
->value
.value
= value
;
207 new_e
->value
.str
= NULL
;
208 new_e
->type
.node_class
= etree_value
;
213 exp_bigintop (bfd_vma value
, char *str
)
215 etree_type
*new_e
= stat_alloc (sizeof (new_e
->value
));
216 new_e
->type
.node_code
= INT
;
217 new_e
->type
.filename
= ldlex_filename ();
218 new_e
->type
.lineno
= lineno
;
219 new_e
->value
.value
= value
;
220 new_e
->value
.str
= str
;
221 new_e
->type
.node_class
= etree_value
;
225 /* Build an expression representing an unnamed relocatable value. */
228 exp_relop (asection
*section
, bfd_vma value
)
230 etree_type
*new_e
= stat_alloc (sizeof (new_e
->rel
));
231 new_e
->type
.node_code
= REL
;
232 new_e
->type
.filename
= ldlex_filename ();
233 new_e
->type
.lineno
= lineno
;
234 new_e
->type
.node_class
= etree_rel
;
235 new_e
->rel
.section
= section
;
236 new_e
->rel
.value
= value
;
241 new_number (bfd_vma value
)
243 expld
.result
.valid_p
= TRUE
;
244 expld
.result
.value
= value
;
245 expld
.result
.str
= NULL
;
246 expld
.result
.section
= NULL
;
250 new_rel (bfd_vma value
, asection
*section
)
252 expld
.result
.valid_p
= TRUE
;
253 expld
.result
.value
= value
;
254 expld
.result
.str
= NULL
;
255 expld
.result
.section
= section
;
259 new_rel_from_abs (bfd_vma value
)
261 asection
*s
= expld
.section
;
263 expld
.rel_from_abs
= TRUE
;
264 expld
.result
.valid_p
= TRUE
;
265 expld
.result
.value
= value
- s
->vma
;
266 expld
.result
.str
= NULL
;
267 expld
.result
.section
= s
;
270 /* New-function for the definedness hash table. */
272 static struct bfd_hash_entry
*
273 definedness_newfunc (struct bfd_hash_entry
*entry
,
274 struct bfd_hash_table
*table ATTRIBUTE_UNUSED
,
275 const char *name ATTRIBUTE_UNUSED
)
277 struct definedness_hash_entry
*ret
= (struct definedness_hash_entry
*) entry
;
280 ret
= (struct definedness_hash_entry
*)
281 bfd_hash_allocate (table
, sizeof (struct definedness_hash_entry
));
284 einfo (_("%F%P: bfd_hash_allocate failed creating symbol %s\n"), name
);
291 /* Called during processing of linker script script expressions.
292 For symbols assigned in a linker script, return a struct describing
293 where the symbol is defined relative to the current expression,
294 otherwise return NULL. */
296 static struct definedness_hash_entry
*
297 symbol_defined (const char *name
)
299 return ((struct definedness_hash_entry
*)
300 bfd_hash_lookup (&definedness_table
, name
, FALSE
, FALSE
));
303 /* Update the definedness state of NAME. Return FALSE if script symbol
304 is multiply defining a strong symbol in an object. */
307 update_definedness (const char *name
, struct bfd_link_hash_entry
*h
)
310 struct definedness_hash_entry
*defentry
311 = (struct definedness_hash_entry
*)
312 bfd_hash_lookup (&definedness_table
, name
, TRUE
, FALSE
);
314 if (defentry
== NULL
)
315 einfo (_("%F%P: bfd_hash_lookup failed creating symbol %s\n"), name
);
317 /* If the symbol was already defined, and not by a script, then it
318 must be defined by an object file or by the linker target code. */
321 && (h
->type
== bfd_link_hash_defined
322 || h
->type
== bfd_link_hash_defweak
323 || h
->type
== bfd_link_hash_common
))
325 defentry
->by_object
= 1;
326 if (h
->type
== bfd_link_hash_defined
327 && h
->u
.def
.section
->output_section
!= NULL
332 defentry
->iteration
= lang_statement_iteration
;
333 defentry
->final_sec
= bfd_abs_section_ptr
;
334 if (expld
.phase
== lang_final_phase_enum
335 && expld
.rel_from_abs
336 && expld
.result
.section
== bfd_abs_section_ptr
)
337 defentry
->final_sec
= section_for_dot ();
342 fold_segment_end (seg_align_type
*seg
)
344 if (expld
.phase
== lang_first_phase_enum
345 || expld
.section
!= bfd_abs_section_ptr
)
347 expld
.result
.valid_p
= FALSE
;
349 else if (seg
->phase
== exp_seg_align_seen
350 || seg
->phase
== exp_seg_relro_seen
)
352 seg
->phase
= exp_seg_end_seen
;
353 seg
->end
= expld
.result
.value
;
355 else if (seg
->phase
== exp_seg_done
356 || seg
->phase
== exp_seg_adjust
357 || seg
->phase
== exp_seg_relro_adjust
)
362 expld
.result
.valid_p
= FALSE
;
366 fold_unary (etree_type
*tree
)
368 exp_fold_tree_1 (tree
->unary
.child
);
369 if (expld
.result
.valid_p
)
371 switch (tree
->type
.node_code
)
374 if (expld
.phase
!= lang_first_phase_enum
)
375 new_rel_from_abs (align_n (expld
.dot
, expld
.result
.value
));
377 expld
.result
.valid_p
= FALSE
;
389 expld
.result
.value
= ~expld
.result
.value
;
393 expld
.result
.value
= !expld
.result
.value
;
397 expld
.result
.value
= -expld
.result
.value
;
401 /* Return next place aligned to value. */
402 if (expld
.phase
!= lang_first_phase_enum
)
405 expld
.result
.value
= align_n (expld
.dot
, expld
.result
.value
);
408 expld
.result
.valid_p
= FALSE
;
411 case DATA_SEGMENT_END
:
412 fold_segment_end (&expld
.dataseg
);
422 /* Arithmetic operators, bitwise AND, bitwise OR and XOR keep the
423 section of one of their operands only when the other operand is a
424 plain number. Losing the section when operating on two symbols,
425 ie. a result of a plain number, is required for subtraction and
426 XOR. It's justifiable for the other operations on the grounds that
427 adding, multiplying etc. two section relative values does not
428 really make sense unless they are just treated as numbers.
429 The same argument could be made for many expressions involving one
430 symbol and a number. For example, "1 << x" and "100 / x" probably
431 should not be given the section of x. The trouble is that if we
432 fuss about such things the rules become complex and it is onerous
433 to document ld expression evaluation. */
435 arith_result_section (const etree_value_type
*lhs
)
437 if (expld
.result
.section
== lhs
->section
)
439 if (expld
.section
== bfd_abs_section_ptr
440 && !config
.sane_expr
)
441 /* Duplicate the insanity in exp_fold_tree_1 case etree_value. */
442 expld
.result
.section
= bfd_abs_section_ptr
;
444 expld
.result
.section
= NULL
;
449 fold_segment_align (seg_align_type
*seg
, etree_value_type
*lhs
)
451 seg
->relro
= exp_seg_relro_start
;
452 if (expld
.phase
== lang_first_phase_enum
453 || expld
.section
!= bfd_abs_section_ptr
)
454 expld
.result
.valid_p
= FALSE
;
457 bfd_vma maxpage
= lhs
->value
;
458 bfd_vma commonpage
= expld
.result
.value
;
460 expld
.result
.value
= align_n (expld
.dot
, maxpage
);
461 if (seg
->phase
== exp_seg_relro_adjust
)
462 expld
.result
.value
= seg
->base
;
463 else if (seg
->phase
== exp_seg_adjust
)
465 if (commonpage
< maxpage
)
466 expld
.result
.value
+= ((expld
.dot
+ commonpage
- 1)
467 & (maxpage
- commonpage
));
471 expld
.result
.value
+= expld
.dot
& (maxpage
- 1);
472 if (seg
->phase
== exp_seg_done
)
476 else if (seg
->phase
== exp_seg_none
)
478 seg
->phase
= exp_seg_align_seen
;
479 seg
->base
= expld
.result
.value
;
480 seg
->pagesize
= commonpage
;
481 seg
->maxpagesize
= maxpage
;
485 expld
.result
.valid_p
= FALSE
;
491 fold_segment_relro_end (seg_align_type
*seg
, etree_value_type
*lhs
)
493 /* Operands swapped! XXX_SEGMENT_RELRO_END(offset,exp) has offset
494 in expld.result and exp in lhs. */
495 seg
->relro
= exp_seg_relro_end
;
496 seg
->relro_offset
= expld
.result
.value
;
497 if (expld
.phase
== lang_first_phase_enum
498 || expld
.section
!= bfd_abs_section_ptr
)
499 expld
.result
.valid_p
= FALSE
;
500 else if (seg
->phase
== exp_seg_align_seen
501 || seg
->phase
== exp_seg_adjust
502 || seg
->phase
== exp_seg_relro_adjust
503 || seg
->phase
== exp_seg_done
)
505 if (seg
->phase
== exp_seg_align_seen
506 || seg
->phase
== exp_seg_relro_adjust
)
507 seg
->relro_end
= lhs
->value
+ expld
.result
.value
;
509 if (seg
->phase
== exp_seg_relro_adjust
510 && (seg
->relro_end
& (seg
->pagesize
- 1)))
512 seg
->relro_end
+= seg
->pagesize
- 1;
513 seg
->relro_end
&= ~(seg
->pagesize
- 1);
514 expld
.result
.value
= seg
->relro_end
- expld
.result
.value
;
517 expld
.result
.value
= lhs
->value
;
519 if (seg
->phase
== exp_seg_align_seen
)
520 seg
->phase
= exp_seg_relro_seen
;
523 expld
.result
.valid_p
= FALSE
;
527 fold_binary (etree_type
*tree
)
529 etree_value_type lhs
;
530 exp_fold_tree_1 (tree
->binary
.lhs
);
532 /* The SEGMENT_START operator is special because its first
533 operand is a string, not the name of a symbol. Note that the
534 operands have been swapped, so binary.lhs is second (default)
535 operand, binary.rhs is first operand. */
536 if (expld
.result
.valid_p
&& tree
->type
.node_code
== SEGMENT_START
)
538 bfd_vma value
= expld
.result
.value
;
539 const char *segment_name
;
542 /* Check to see if the user has overridden the default
544 segment_name
= tree
->binary
.rhs
->name
.name
;
545 for (seg
= segments
; seg
; seg
= seg
->next
)
546 if (strcmp (seg
->name
, segment_name
) == 0)
549 && config
.magic_demand_paged
550 && config
.maxpagesize
!= 0
551 && (seg
->value
% config
.maxpagesize
) != 0)
552 einfo (_("%P: warning: address of `%s' "
553 "isn't multiple of maximum page size\n"),
559 new_rel_from_abs (value
);
564 exp_fold_tree_1 (tree
->binary
.rhs
);
565 expld
.result
.valid_p
&= lhs
.valid_p
;
567 if (expld
.result
.valid_p
)
569 if (lhs
.section
!= expld
.result
.section
)
571 /* If the values are from different sections, and neither is
572 just a number, make both the source arguments absolute. */
573 if (expld
.result
.section
!= NULL
574 && lhs
.section
!= NULL
)
577 lhs
.value
+= lhs
.section
->vma
;
578 lhs
.section
= bfd_abs_section_ptr
;
581 /* If the rhs is just a number, keep the lhs section. */
582 else if (expld
.result
.section
== NULL
)
584 expld
.result
.section
= lhs
.section
;
585 /* Make this NULL so that we know one of the operands
586 was just a number, for later tests. */
590 /* At this point we know that both operands have the same
591 section, or at least one of them is a plain number. */
593 switch (tree
->type
.node_code
)
597 expld.result.value = lhs.value y expld.result.value; \
598 arith_result_section (&lhs); \
601 /* Comparison operators, logical AND, and logical OR always
602 return a plain number. */
605 expld.result.value = lhs.value y expld.result.value; \
606 expld.result.section = NULL; \
627 if (expld
.result
.value
!= 0)
628 expld
.result
.value
= ((bfd_signed_vma
) lhs
.value
629 % (bfd_signed_vma
) expld
.result
.value
);
630 else if (expld
.phase
!= lang_mark_phase_enum
)
631 einfo (_("%F%P:%pS %% by zero\n"), tree
->binary
.rhs
);
632 arith_result_section (&lhs
);
636 if (expld
.result
.value
!= 0)
637 expld
.result
.value
= ((bfd_signed_vma
) lhs
.value
638 / (bfd_signed_vma
) expld
.result
.value
);
639 else if (expld
.phase
!= lang_mark_phase_enum
)
640 einfo (_("%F%P:%pS / by zero\n"), tree
->binary
.rhs
);
641 arith_result_section (&lhs
);
645 if (lhs
.value
> expld
.result
.value
)
646 expld
.result
.value
= lhs
.value
;
650 if (lhs
.value
< expld
.result
.value
)
651 expld
.result
.value
= lhs
.value
;
655 expld
.result
.value
= align_n (lhs
.value
, expld
.result
.value
);
658 case DATA_SEGMENT_ALIGN
:
659 fold_segment_align (&expld
.dataseg
, &lhs
);
662 case DATA_SEGMENT_RELRO_END
:
663 fold_segment_relro_end (&expld
.dataseg
, &lhs
);
673 fold_trinary (etree_type
*tree
)
675 struct bfd_link_hash_entry
*save
= expld
.assign_src
;
677 exp_fold_tree_1 (tree
->trinary
.cond
);
678 expld
.assign_src
= save
;
679 if (expld
.result
.valid_p
)
680 exp_fold_tree_1 (expld
.result
.value
682 : tree
->trinary
.rhs
);
686 fold_name (etree_type
*tree
)
688 struct bfd_link_hash_entry
*h
;
689 struct definedness_hash_entry
*def
;
691 memset (&expld
.result
, 0, sizeof (expld
.result
));
693 switch (tree
->type
.node_code
)
696 link_info
.load_phdrs
= 1;
697 if (expld
.phase
!= lang_first_phase_enum
)
699 bfd_vma hdr_size
= 0;
700 /* Don't find the real header size if only marking sections;
701 The bfd function may cache incorrect data. */
702 if (expld
.phase
!= lang_mark_phase_enum
)
703 hdr_size
= bfd_sizeof_headers (link_info
.output_bfd
, &link_info
);
704 new_number (hdr_size
);
709 h
= bfd_wrapped_link_hash_lookup (link_info
.output_bfd
,
713 new_number (h
!= NULL
714 && (h
->type
== bfd_link_hash_defined
715 || h
->type
== bfd_link_hash_defweak
716 || h
->type
== bfd_link_hash_common
)
718 || (def
= symbol_defined (tree
->name
.name
)) == NULL
720 || def
->iteration
== (lang_statement_iteration
& 255)));
724 if (tree
->name
.name
[0] == '.' && tree
->name
.name
[1] == 0)
725 new_rel_from_abs (expld
.dot
);
728 h
= bfd_wrapped_link_hash_lookup (link_info
.output_bfd
,
733 einfo (_("%F%P: bfd_link_hash_lookup failed: %E\n"));
734 else if (h
->type
== bfd_link_hash_defined
735 || h
->type
== bfd_link_hash_defweak
)
737 asection
*output_section
;
739 output_section
= h
->u
.def
.section
->output_section
;
740 if (output_section
== NULL
)
742 if (expld
.phase
<= lang_mark_phase_enum
)
743 new_rel (h
->u
.def
.value
, h
->u
.def
.section
);
745 einfo (_("%X%P:%pS: unresolvable symbol `%s'"
746 " referenced in expression\n"),
747 tree
, tree
->name
.name
);
749 else if (output_section
== bfd_abs_section_ptr
750 && (expld
.section
!= bfd_abs_section_ptr
751 || config
.sane_expr
))
752 new_number (h
->u
.def
.value
+ h
->u
.def
.section
->output_offset
);
754 new_rel (h
->u
.def
.value
+ h
->u
.def
.section
->output_offset
,
757 else if (expld
.phase
== lang_final_phase_enum
758 || (expld
.phase
!= lang_mark_phase_enum
759 && expld
.assigning_to_dot
))
760 einfo (_("%F%P:%pS: undefined symbol `%s'"
761 " referenced in expression\n"),
762 tree
, tree
->name
.name
);
763 else if (h
->type
== bfd_link_hash_new
)
765 h
->type
= bfd_link_hash_undefined
;
766 h
->u
.undef
.abfd
= NULL
;
767 if (h
->u
.undef
.next
== NULL
&& h
!= link_info
.hash
->undefs_tail
)
768 bfd_link_add_undef (link_info
.hash
, h
);
770 if (expld
.assign_src
== NULL
)
771 expld
.assign_src
= h
;
773 expld
.assign_src
= (struct bfd_link_hash_entry
*) - 1;
775 /* Self-assignment is only allowed for absolute symbols
776 defined in a linker script. */
777 if (expld
.assign_name
!= NULL
778 && strcmp (expld
.assign_name
, tree
->name
.name
) == 0
780 && (h
->type
== bfd_link_hash_defined
781 || h
->type
== bfd_link_hash_defweak
)
782 && h
->u
.def
.section
== bfd_abs_section_ptr
783 && (def
= symbol_defined (tree
->name
.name
)) != NULL
784 && def
->iteration
== (lang_statement_iteration
& 255)))
785 expld
.assign_name
= NULL
;
790 if (expld
.phase
!= lang_first_phase_enum
)
792 lang_output_section_statement_type
*os
;
794 os
= lang_output_section_find (tree
->name
.name
);
797 if (expld
.phase
== lang_final_phase_enum
)
798 einfo (_("%F%P:%pS: undefined section `%s'"
799 " referenced in expression\n"),
800 tree
, tree
->name
.name
);
802 else if (os
->processed_vma
)
803 new_rel (0, os
->bfd_section
);
808 if (expld
.phase
!= lang_first_phase_enum
)
810 lang_output_section_statement_type
*os
;
812 os
= lang_output_section_find (tree
->name
.name
);
815 if (expld
.phase
== lang_final_phase_enum
)
816 einfo (_("%F%P:%pS: undefined section `%s'"
817 " referenced in expression\n"),
818 tree
, tree
->name
.name
);
820 else if (os
->processed_lma
)
822 if (os
->load_base
== NULL
)
823 new_abs (os
->bfd_section
->lma
);
826 exp_fold_tree_1 (os
->load_base
);
827 if (expld
.result
.valid_p
)
836 if (expld
.phase
!= lang_first_phase_enum
)
838 lang_output_section_statement_type
*os
;
840 os
= lang_output_section_find (tree
->name
.name
);
843 if (expld
.phase
== lang_final_phase_enum
)
844 einfo (_("%F%P:%pS: undefined section `%s'"
845 " referenced in expression\n"),
846 tree
, tree
->name
.name
);
849 else if (os
->bfd_section
!= NULL
)
853 if (tree
->type
.node_code
== SIZEOF
)
854 val
= (os
->bfd_section
->size
855 / bfd_octets_per_byte (link_info
.output_bfd
));
857 val
= (bfd_vma
)1 << os
->bfd_section
->alignment_power
;
868 lang_memory_region_type
*mem
;
870 mem
= lang_memory_region_lookup (tree
->name
.name
, FALSE
);
872 new_number (mem
->length
);
874 einfo (_("%F%P:%pS: undefined MEMORY region `%s'"
875 " referenced in expression\n"),
876 tree
, tree
->name
.name
);
882 lang_memory_region_type
*mem
;
884 mem
= lang_memory_region_lookup (tree
->name
.name
, FALSE
);
886 new_rel_from_abs (mem
->origin
);
888 einfo (_("%F%P:%pS: undefined MEMORY region `%s'"
889 " referenced in expression\n"),
890 tree
, tree
->name
.name
);
895 if (strcmp (tree
->name
.name
, "MAXPAGESIZE") == 0)
896 new_number (config
.maxpagesize
);
897 else if (strcmp (tree
->name
.name
, "COMMONPAGESIZE") == 0)
898 new_number (config
.commonpagesize
);
900 einfo (_("%F%P:%pS: unknown constant `%s' referenced in expression\n"),
901 tree
, tree
->name
.name
);
910 /* Return true if TREE is '.'. */
913 is_dot (const etree_type
*tree
)
915 return (tree
->type
.node_class
== etree_name
916 && tree
->type
.node_code
== NAME
917 && tree
->name
.name
[0] == '.'
918 && tree
->name
.name
[1] == 0);
921 /* Return true if TREE is a constant equal to VAL. */
924 is_value (const etree_type
*tree
, bfd_vma val
)
926 return (tree
->type
.node_class
== etree_value
927 && tree
->value
.value
== val
);
930 /* Return true if TREE is an absolute symbol equal to VAL defined in
934 is_sym_value (const etree_type
*tree
, bfd_vma val
)
936 struct bfd_link_hash_entry
*h
;
937 struct definedness_hash_entry
*def
;
939 return (tree
->type
.node_class
== etree_name
940 && tree
->type
.node_code
== NAME
941 && (def
= symbol_defined (tree
->name
.name
)) != NULL
942 && def
->iteration
== (lang_statement_iteration
& 255)
943 && (h
= bfd_wrapped_link_hash_lookup (link_info
.output_bfd
,
946 FALSE
, FALSE
, TRUE
)) != NULL
948 && h
->type
== bfd_link_hash_defined
949 && h
->u
.def
.section
== bfd_abs_section_ptr
950 && h
->u
.def
.value
== val
);
953 /* Return true if TREE is ". != 0". */
956 is_dot_ne_0 (const etree_type
*tree
)
958 return (tree
->type
.node_class
== etree_binary
959 && tree
->type
.node_code
== NE
960 && is_dot (tree
->binary
.lhs
)
961 && is_value (tree
->binary
.rhs
, 0));
964 /* Return true if TREE is ". = . + 0" or ". = . + sym" where sym is an
965 absolute constant with value 0 defined in a linker script. */
968 is_dot_plus_0 (const etree_type
*tree
)
970 return (tree
->type
.node_class
== etree_binary
971 && tree
->type
.node_code
== '+'
972 && is_dot (tree
->binary
.lhs
)
973 && (is_value (tree
->binary
.rhs
, 0)
974 || is_sym_value (tree
->binary
.rhs
, 0)));
977 /* Return true if TREE is "ALIGN (. != 0 ? some_expression : 1)". */
980 is_align_conditional (const etree_type
*tree
)
982 if (tree
->type
.node_class
== etree_unary
983 && tree
->type
.node_code
== ALIGN_K
)
985 tree
= tree
->unary
.child
;
986 return (tree
->type
.node_class
== etree_trinary
987 && is_dot_ne_0 (tree
->trinary
.cond
)
988 && is_value (tree
->trinary
.rhs
, 1));
994 exp_fold_tree_1 (etree_type
*tree
)
998 memset (&expld
.result
, 0, sizeof (expld
.result
));
1002 switch (tree
->type
.node_class
)
1005 if (expld
.section
== bfd_abs_section_ptr
1006 && !config
.sane_expr
)
1007 new_abs (tree
->value
.value
);
1009 new_number (tree
->value
.value
);
1010 expld
.result
.str
= tree
->value
.str
;
1014 if (expld
.phase
!= lang_first_phase_enum
)
1016 asection
*output_section
= tree
->rel
.section
->output_section
;
1017 new_rel (tree
->rel
.value
+ tree
->rel
.section
->output_offset
,
1021 memset (&expld
.result
, 0, sizeof (expld
.result
));
1025 exp_fold_tree_1 (tree
->assert_s
.child
);
1026 if (expld
.phase
== lang_final_phase_enum
&& !expld
.result
.value
)
1027 einfo ("%X%P: %s\n", tree
->assert_s
.message
);
1039 fold_trinary (tree
);
1044 case etree_provided
:
1045 if (tree
->assign
.dst
[0] == '.' && tree
->assign
.dst
[1] == 0)
1047 if (tree
->type
.node_class
!= etree_assign
)
1048 einfo (_("%F%P:%pS can not PROVIDE assignment to"
1049 " location counter\n"), tree
);
1050 if (expld
.phase
!= lang_first_phase_enum
)
1052 /* Notify the folder that this is an assignment to dot. */
1053 expld
.assigning_to_dot
= TRUE
;
1054 exp_fold_tree_1 (tree
->assign
.src
);
1055 expld
.assigning_to_dot
= FALSE
;
1057 /* If we are assigning to dot inside an output section
1058 arrange to keep the section, except for certain
1059 expressions that evaluate to zero. We ignore . = 0,
1060 . = . + 0, and . = ALIGN (. != 0 ? expr : 1).
1061 We can't ignore all expressions that evaluate to zero
1062 because an otherwise empty section might have padding
1063 added by an alignment expression that changes with
1064 relaxation. Such a section might have zero size
1065 before relaxation and so be stripped incorrectly. */
1066 if (expld
.phase
== lang_mark_phase_enum
1067 && expld
.section
!= bfd_abs_section_ptr
1068 && expld
.section
!= bfd_und_section_ptr
1069 && !(expld
.result
.valid_p
1070 && expld
.result
.value
== 0
1071 && (is_value (tree
->assign
.src
, 0)
1072 || is_sym_value (tree
->assign
.src
, 0)
1073 || is_dot_plus_0 (tree
->assign
.src
)
1074 || is_align_conditional (tree
->assign
.src
))))
1075 expld
.section
->flags
|= SEC_KEEP
;
1077 if (!expld
.result
.valid_p
1078 || expld
.section
== bfd_und_section_ptr
)
1080 if (expld
.phase
!= lang_mark_phase_enum
)
1081 einfo (_("%F%P:%pS invalid assignment to"
1082 " location counter\n"), tree
);
1084 else if (expld
.dotp
== NULL
)
1085 einfo (_("%F%P:%pS assignment to location counter"
1086 " invalid outside of SECTIONS\n"), tree
);
1088 /* After allocation, assignment to dot should not be
1089 done inside an output section since allocation adds a
1090 padding statement that effectively duplicates the
1092 else if (expld
.phase
<= lang_allocating_phase_enum
1093 || expld
.section
== bfd_abs_section_ptr
)
1097 nextdot
= expld
.result
.value
;
1098 if (expld
.result
.section
!= NULL
)
1099 nextdot
+= expld
.result
.section
->vma
;
1101 nextdot
+= expld
.section
->vma
;
1102 if (nextdot
< expld
.dot
1103 && expld
.section
!= bfd_abs_section_ptr
)
1104 einfo (_("%F%P:%pS cannot move location counter backwards"
1105 " (from %V to %V)\n"),
1106 tree
, expld
.dot
, nextdot
);
1109 expld
.dot
= nextdot
;
1110 *expld
.dotp
= nextdot
;
1115 memset (&expld
.result
, 0, sizeof (expld
.result
));
1119 struct bfd_link_hash_entry
*h
= NULL
;
1121 if (tree
->type
.node_class
== etree_provide
)
1123 h
= bfd_link_hash_lookup (link_info
.hash
, tree
->assign
.dst
,
1124 FALSE
, FALSE
, TRUE
);
1126 || !(h
->type
== bfd_link_hash_new
1127 || h
->type
== bfd_link_hash_undefined
1128 || h
->type
== bfd_link_hash_undefweak
1131 /* Do nothing. The symbol was never referenced, or
1132 was defined in some object file. Note that
1133 undefweak symbols are defined by PROVIDE. This
1134 is to support glibc use of __rela_iplt_start and
1135 similar weak references. */
1140 expld
.assign_name
= tree
->assign
.dst
;
1141 expld
.assign_src
= NULL
;
1142 exp_fold_tree_1 (tree
->assign
.src
);
1143 /* expld.assign_name remaining equal to tree->assign.dst
1144 below indicates the evaluation of tree->assign.src did
1145 not use the value of tree->assign.dst. We don't allow
1146 self assignment until the final phase for two reasons:
1147 1) Expressions are evaluated multiple times. With
1148 relaxation, the number of times may vary.
1149 2) Section relative symbol values cannot be correctly
1150 converted to absolute values, as is required by many
1151 expressions, until final section sizing is complete. */
1152 if (expld
.phase
== lang_final_phase_enum
1153 || expld
.phase
== lang_fixed_phase_enum
1154 || expld
.assign_name
!= NULL
)
1156 if (tree
->type
.node_class
== etree_provide
)
1157 tree
->type
.node_class
= etree_provided
;
1161 h
= bfd_link_hash_lookup (link_info
.hash
, tree
->assign
.dst
,
1164 einfo (_("%F%P:%s: hash creation failed\n"),
1168 /* If the expression is not valid then fake a zero value. In
1169 the final phase any errors will already have been raised,
1170 in earlier phases we want to create this definition so
1171 that it can be seen by other expressions. */
1172 if (!expld
.result
.valid_p
1173 && h
->type
== bfd_link_hash_new
)
1175 expld
.result
.value
= 0;
1176 expld
.result
.section
= NULL
;
1177 expld
.result
.valid_p
= TRUE
;
1180 if (expld
.result
.valid_p
)
1182 if (expld
.result
.section
== NULL
)
1183 expld
.result
.section
= expld
.section
;
1184 if (!update_definedness (tree
->assign
.dst
, h
) && 0)
1186 /* Symbol was already defined. For now this error
1187 is disabled because it causes failures in the ld
1188 testsuite: ld-elf/var1, ld-scripts/defined5, and
1189 ld-scripts/pr14962. Some of these no doubt
1190 reflect scripts used in the wild. */
1191 (*link_info
.callbacks
->multiple_definition
)
1192 (&link_info
, h
, link_info
.output_bfd
,
1193 expld
.result
.section
, expld
.result
.value
);
1195 if (expld
.phase
== lang_fixed_phase_enum
)
1197 if (h
->type
== bfd_link_hash_defined
)
1199 expld
.result
.value
= h
->u
.def
.value
;
1200 expld
.result
.section
= h
->u
.def
.section
;
1205 h
->type
= bfd_link_hash_defined
;
1206 h
->u
.def
.value
= expld
.result
.value
;
1207 h
->u
.def
.section
= expld
.result
.section
;
1208 h
->linker_def
= ! tree
->assign
.type
.lineno
;
1209 h
->ldscript_def
= 1;
1210 h
->rel_from_abs
= expld
.rel_from_abs
;
1211 if (tree
->assign
.hidden
)
1212 bfd_link_hide_symbol (link_info
.output_bfd
,
1215 /* Copy the symbol type if this is an expression only
1216 referencing a single symbol. (If the expression
1217 contains ternary conditions, ignoring symbols on
1219 if (expld
.assign_src
!= NULL
1220 && (expld
.assign_src
1221 != (struct bfd_link_hash_entry
*) -1))
1222 bfd_copy_link_hash_symbol_type (link_info
.output_bfd
,
1223 h
, expld
.assign_src
);
1227 if (expld
.phase
!= lang_fixed_phase_enum
)
1228 expld
.assign_name
= NULL
;
1238 memset (&expld
.result
, 0, sizeof (expld
.result
));
1244 exp_fold_tree (etree_type
*tree
, asection
*current_section
, bfd_vma
*dotp
)
1246 expld
.rel_from_abs
= FALSE
;
1249 expld
.section
= current_section
;
1250 exp_fold_tree_1 (tree
);
1254 exp_fold_tree_no_dot (etree_type
*tree
)
1256 expld
.rel_from_abs
= FALSE
;
1259 expld
.section
= bfd_abs_section_ptr
;
1260 exp_fold_tree_1 (tree
);
1264 exp_value_fold (etree_type
*tree
)
1266 exp_fold_tree_no_dot (tree
);
1267 if (expld
.result
.valid_p
)
1269 tree
->type
.node_code
= INT
;
1270 tree
->value
.value
= expld
.result
.value
;
1271 tree
->value
.str
= NULL
;
1272 tree
->type
.node_class
= etree_value
;
1276 #define MAX(a, b) ((a) > (b) ? (a) : (b))
1279 exp_binop (int code
, etree_type
*lhs
, etree_type
*rhs
)
1281 etree_type
*new_e
= stat_alloc (MAX (sizeof (new_e
->binary
),
1282 sizeof (new_e
->value
)));
1283 new_e
->type
.node_code
= code
;
1284 new_e
->type
.filename
= lhs
->type
.filename
;
1285 new_e
->type
.lineno
= lhs
->type
.lineno
;
1286 new_e
->binary
.lhs
= lhs
;
1287 new_e
->binary
.rhs
= rhs
;
1288 new_e
->type
.node_class
= etree_binary
;
1289 if (lhs
->type
.node_class
== etree_value
1290 && rhs
->type
.node_class
== etree_value
1292 && code
!= DATA_SEGMENT_ALIGN
1293 && code
!= DATA_SEGMENT_RELRO_END
)
1294 exp_value_fold (new_e
);
1299 exp_trinop (int code
, etree_type
*cond
, etree_type
*lhs
, etree_type
*rhs
)
1301 etree_type
*new_e
= stat_alloc (MAX (sizeof (new_e
->trinary
),
1302 sizeof (new_e
->value
)));
1303 new_e
->type
.node_code
= code
;
1304 new_e
->type
.filename
= cond
->type
.filename
;
1305 new_e
->type
.lineno
= cond
->type
.lineno
;
1306 new_e
->trinary
.lhs
= lhs
;
1307 new_e
->trinary
.cond
= cond
;
1308 new_e
->trinary
.rhs
= rhs
;
1309 new_e
->type
.node_class
= etree_trinary
;
1310 if (cond
->type
.node_class
== etree_value
1311 && lhs
->type
.node_class
== etree_value
1312 && rhs
->type
.node_class
== etree_value
)
1313 exp_value_fold (new_e
);
1318 exp_unop (int code
, etree_type
*child
)
1320 etree_type
*new_e
= stat_alloc (MAX (sizeof (new_e
->unary
),
1321 sizeof (new_e
->value
)));
1322 new_e
->unary
.type
.node_code
= code
;
1323 new_e
->unary
.type
.filename
= child
->type
.filename
;
1324 new_e
->unary
.type
.lineno
= child
->type
.lineno
;
1325 new_e
->unary
.child
= child
;
1326 new_e
->unary
.type
.node_class
= etree_unary
;
1327 if (child
->type
.node_class
== etree_value
1331 && code
!= DATA_SEGMENT_END
)
1332 exp_value_fold (new_e
);
1337 exp_nameop (int code
, const char *name
)
1339 etree_type
*new_e
= stat_alloc (sizeof (new_e
->name
));
1341 new_e
->name
.type
.node_code
= code
;
1342 new_e
->name
.type
.filename
= ldlex_filename ();
1343 new_e
->name
.type
.lineno
= lineno
;
1344 new_e
->name
.name
= name
;
1345 new_e
->name
.type
.node_class
= etree_name
;
1351 exp_assop (const char *dst
,
1353 enum node_tree_enum
class,
1358 n
= stat_alloc (sizeof (n
->assign
));
1359 n
->assign
.type
.node_code
= '=';
1360 n
->assign
.type
.filename
= src
->type
.filename
;
1361 n
->assign
.type
.lineno
= src
->type
.lineno
;
1362 n
->assign
.type
.node_class
= class;
1363 n
->assign
.src
= src
;
1364 n
->assign
.dst
= dst
;
1365 n
->assign
.hidden
= hidden
;
1369 /* Handle linker script assignments and HIDDEN. */
1372 exp_assign (const char *dst
, etree_type
*src
, bfd_boolean hidden
)
1374 return exp_assop (dst
, src
, etree_assign
, hidden
);
1377 /* Handle --defsym command-line option. */
1380 exp_defsym (const char *dst
, etree_type
*src
)
1382 return exp_assop (dst
, src
, etree_assign
, FALSE
);
1385 /* Handle PROVIDE. */
1388 exp_provide (const char *dst
, etree_type
*src
, bfd_boolean hidden
)
1390 return exp_assop (dst
, src
, etree_provide
, hidden
);
1393 /* Handle ASSERT. */
1396 exp_assert (etree_type
*exp
, const char *message
)
1400 n
= stat_alloc (sizeof (n
->assert_s
));
1401 n
->assert_s
.type
.node_code
= '!';
1402 n
->assert_s
.type
.filename
= exp
->type
.filename
;
1403 n
->assert_s
.type
.lineno
= exp
->type
.lineno
;
1404 n
->assert_s
.type
.node_class
= etree_assert
;
1405 n
->assert_s
.child
= exp
;
1406 n
->assert_s
.message
= message
;
1411 exp_print_tree (etree_type
*tree
)
1413 bfd_boolean function_like
;
1415 if (config
.map_file
== NULL
)
1416 config
.map_file
= stderr
;
1420 minfo ("NULL TREE\n");
1424 switch (tree
->type
.node_class
)
1427 minfo ("0x%v", tree
->value
.value
);
1430 if (tree
->rel
.section
->owner
!= NULL
)
1431 minfo ("%pB:", tree
->rel
.section
->owner
);
1432 minfo ("%s+0x%v", tree
->rel
.section
->name
, tree
->rel
.value
);
1435 fputs (tree
->assign
.dst
, config
.map_file
);
1436 exp_print_token (tree
->type
.node_code
, TRUE
);
1437 exp_print_tree (tree
->assign
.src
);
1440 case etree_provided
:
1441 fprintf (config
.map_file
, "PROVIDE (%s = ", tree
->assign
.dst
);
1442 exp_print_tree (tree
->assign
.src
);
1443 fputc (')', config
.map_file
);
1446 function_like
= FALSE
;
1447 switch (tree
->type
.node_code
)
1452 case DATA_SEGMENT_ALIGN
:
1453 case DATA_SEGMENT_RELRO_END
:
1454 function_like
= TRUE
;
1457 /* Special handling because arguments are in reverse order and
1458 the segment name is quoted. */
1459 exp_print_token (tree
->type
.node_code
, FALSE
);
1460 fputs (" (\"", config
.map_file
);
1461 exp_print_tree (tree
->binary
.rhs
);
1462 fputs ("\", ", config
.map_file
);
1463 exp_print_tree (tree
->binary
.lhs
);
1464 fputc (')', config
.map_file
);
1469 exp_print_token (tree
->type
.node_code
, FALSE
);
1470 fputc (' ', config
.map_file
);
1472 fputc ('(', config
.map_file
);
1473 exp_print_tree (tree
->binary
.lhs
);
1475 fprintf (config
.map_file
, ", ");
1477 exp_print_token (tree
->type
.node_code
, TRUE
);
1478 exp_print_tree (tree
->binary
.rhs
);
1479 fputc (')', config
.map_file
);
1482 exp_print_tree (tree
->trinary
.cond
);
1483 fputc ('?', config
.map_file
);
1484 exp_print_tree (tree
->trinary
.lhs
);
1485 fputc (':', config
.map_file
);
1486 exp_print_tree (tree
->trinary
.rhs
);
1489 exp_print_token (tree
->unary
.type
.node_code
, FALSE
);
1490 if (tree
->unary
.child
)
1492 fprintf (config
.map_file
, " (");
1493 exp_print_tree (tree
->unary
.child
);
1494 fputc (')', config
.map_file
);
1499 fprintf (config
.map_file
, "ASSERT (");
1500 exp_print_tree (tree
->assert_s
.child
);
1501 fprintf (config
.map_file
, ", %s)", tree
->assert_s
.message
);
1505 if (tree
->type
.node_code
== NAME
)
1506 fputs (tree
->name
.name
, config
.map_file
);
1509 exp_print_token (tree
->type
.node_code
, FALSE
);
1510 if (tree
->name
.name
)
1511 fprintf (config
.map_file
, " (%s)", tree
->name
.name
);
1521 exp_get_vma (etree_type
*tree
, bfd_vma def
, char *name
)
1525 exp_fold_tree_no_dot (tree
);
1526 if (expld
.result
.valid_p
)
1527 return expld
.result
.value
;
1528 else if (name
!= NULL
&& expld
.phase
!= lang_mark_phase_enum
)
1529 einfo (_("%F%P:%pS: nonconstant expression for %s\n"),
1535 /* Return the smallest non-negative integer such that two raised to
1536 that power is at least as large as the vma evaluated at TREE, if
1537 TREE is a non-NULL expression that can be resolved. If TREE is
1538 NULL or cannot be resolved, return -1. */
1541 exp_get_power (etree_type
*tree
, char *name
)
1543 bfd_vma x
= exp_get_vma (tree
, -1, name
);
1547 if (x
== (bfd_vma
) -1)
1550 for (n
= 0, p2
= 1; p2
< x
; ++n
, p2
<<= 1)
1558 exp_get_fill (etree_type
*tree
, fill_type
*def
, char *name
)
1567 exp_fold_tree_no_dot (tree
);
1568 if (!expld
.result
.valid_p
)
1570 if (name
!= NULL
&& expld
.phase
!= lang_mark_phase_enum
)
1571 einfo (_("%F%P:%pS: nonconstant expression for %s\n"),
1576 if (expld
.result
.str
!= NULL
&& (len
= strlen (expld
.result
.str
)) != 0)
1580 fill
= (fill_type
*) xmalloc ((len
+ 1) / 2 + sizeof (*fill
) - 1);
1581 fill
->size
= (len
+ 1) / 2;
1583 s
= (unsigned char *) expld
.result
.str
;
1591 digit
= (digit
- 'A' + '0' + 10) & 0xf;
1605 fill
= (fill_type
*) xmalloc (4 + sizeof (*fill
) - 1);
1606 val
= expld
.result
.value
;
1607 fill
->data
[0] = (val
>> 24) & 0xff;
1608 fill
->data
[1] = (val
>> 16) & 0xff;
1609 fill
->data
[2] = (val
>> 8) & 0xff;
1610 fill
->data
[3] = (val
>> 0) & 0xff;
1617 exp_get_abs_int (etree_type
*tree
, int def
, char *name
)
1621 exp_fold_tree_no_dot (tree
);
1623 if (expld
.result
.valid_p
)
1625 if (expld
.result
.section
!= NULL
)
1626 expld
.result
.value
+= expld
.result
.section
->vma
;
1627 return expld
.result
.value
;
1629 else if (name
!= NULL
&& expld
.phase
!= lang_mark_phase_enum
)
1631 einfo (_("%F%P:%pS: nonconstant expression for %s\n"),
1639 align_n (bfd_vma value
, bfd_vma align
)
1644 value
= (value
+ align
- 1) / align
;
1645 return value
* align
;
1651 /* The value "13" is ad-hoc, somewhat related to the expected number of
1652 assignments in a linker script. */
1653 if (!bfd_hash_table_init_n (&definedness_table
,
1654 definedness_newfunc
,
1655 sizeof (struct definedness_hash_entry
),
1657 einfo (_("%F%P: can not create hash table: %E\n"));
1660 /* Convert absolute symbols defined by a script from "dot" (also
1661 SEGMENT_START or ORIGIN) outside of an output section statement,
1662 to section relative. */
1665 set_sym_sections (struct bfd_hash_entry
*bh
, void *inf ATTRIBUTE_UNUSED
)
1667 struct definedness_hash_entry
*def
= (struct definedness_hash_entry
*) bh
;
1668 if (def
->final_sec
!= bfd_abs_section_ptr
)
1670 struct bfd_link_hash_entry
*h
;
1671 h
= bfd_link_hash_lookup (link_info
.hash
, bh
->string
,
1672 FALSE
, FALSE
, TRUE
);
1674 && h
->type
== bfd_link_hash_defined
1675 && h
->u
.def
.section
== bfd_abs_section_ptr
)
1677 h
->u
.def
.value
-= def
->final_sec
->vma
;
1678 h
->u
.def
.section
= def
->final_sec
;
1685 ldexp_finalize_syms (void)
1687 bfd_hash_traverse (&definedness_table
, set_sym_sections
, NULL
);
1693 bfd_hash_table_free (&definedness_table
);