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
,
858 val
= (bfd_vma
)1 << os
->bfd_section
->alignment_power
;
869 lang_memory_region_type
*mem
;
871 mem
= lang_memory_region_lookup (tree
->name
.name
, FALSE
);
873 new_number (mem
->length
);
875 einfo (_("%F%P:%pS: undefined MEMORY region `%s'"
876 " referenced in expression\n"),
877 tree
, tree
->name
.name
);
883 lang_memory_region_type
*mem
;
885 mem
= lang_memory_region_lookup (tree
->name
.name
, FALSE
);
887 new_rel_from_abs (mem
->origin
);
889 einfo (_("%F%P:%pS: undefined MEMORY region `%s'"
890 " referenced in expression\n"),
891 tree
, tree
->name
.name
);
896 if (strcmp (tree
->name
.name
, "MAXPAGESIZE") == 0)
897 new_number (config
.maxpagesize
);
898 else if (strcmp (tree
->name
.name
, "COMMONPAGESIZE") == 0)
899 new_number (config
.commonpagesize
);
901 einfo (_("%F%P:%pS: unknown constant `%s' referenced in expression\n"),
902 tree
, tree
->name
.name
);
911 /* Return true if TREE is '.'. */
914 is_dot (const etree_type
*tree
)
916 return (tree
->type
.node_class
== etree_name
917 && tree
->type
.node_code
== NAME
918 && tree
->name
.name
[0] == '.'
919 && tree
->name
.name
[1] == 0);
922 /* Return true if TREE is a constant equal to VAL. */
925 is_value (const etree_type
*tree
, bfd_vma val
)
927 return (tree
->type
.node_class
== etree_value
928 && tree
->value
.value
== val
);
931 /* Return true if TREE is an absolute symbol equal to VAL defined in
935 is_sym_value (const etree_type
*tree
, bfd_vma val
)
937 struct bfd_link_hash_entry
*h
;
938 struct definedness_hash_entry
*def
;
940 return (tree
->type
.node_class
== etree_name
941 && tree
->type
.node_code
== NAME
942 && (def
= symbol_defined (tree
->name
.name
)) != NULL
943 && def
->iteration
== (lang_statement_iteration
& 255)
944 && (h
= bfd_wrapped_link_hash_lookup (link_info
.output_bfd
,
947 FALSE
, FALSE
, TRUE
)) != NULL
949 && h
->type
== bfd_link_hash_defined
950 && h
->u
.def
.section
== bfd_abs_section_ptr
951 && h
->u
.def
.value
== val
);
954 /* Return true if TREE is ". != 0". */
957 is_dot_ne_0 (const etree_type
*tree
)
959 return (tree
->type
.node_class
== etree_binary
960 && tree
->type
.node_code
== NE
961 && is_dot (tree
->binary
.lhs
)
962 && is_value (tree
->binary
.rhs
, 0));
965 /* Return true if TREE is ". = . + 0" or ". = . + sym" where sym is an
966 absolute constant with value 0 defined in a linker script. */
969 is_dot_plus_0 (const etree_type
*tree
)
971 return (tree
->type
.node_class
== etree_binary
972 && tree
->type
.node_code
== '+'
973 && is_dot (tree
->binary
.lhs
)
974 && (is_value (tree
->binary
.rhs
, 0)
975 || is_sym_value (tree
->binary
.rhs
, 0)));
978 /* Return true if TREE is "ALIGN (. != 0 ? some_expression : 1)". */
981 is_align_conditional (const etree_type
*tree
)
983 if (tree
->type
.node_class
== etree_unary
984 && tree
->type
.node_code
== ALIGN_K
)
986 tree
= tree
->unary
.child
;
987 return (tree
->type
.node_class
== etree_trinary
988 && is_dot_ne_0 (tree
->trinary
.cond
)
989 && is_value (tree
->trinary
.rhs
, 1));
995 exp_fold_tree_1 (etree_type
*tree
)
999 memset (&expld
.result
, 0, sizeof (expld
.result
));
1003 switch (tree
->type
.node_class
)
1006 if (expld
.section
== bfd_abs_section_ptr
1007 && !config
.sane_expr
)
1008 new_abs (tree
->value
.value
);
1010 new_number (tree
->value
.value
);
1011 expld
.result
.str
= tree
->value
.str
;
1015 if (expld
.phase
!= lang_first_phase_enum
)
1017 asection
*output_section
= tree
->rel
.section
->output_section
;
1018 new_rel (tree
->rel
.value
+ tree
->rel
.section
->output_offset
,
1022 memset (&expld
.result
, 0, sizeof (expld
.result
));
1026 exp_fold_tree_1 (tree
->assert_s
.child
);
1027 if (expld
.phase
== lang_final_phase_enum
&& !expld
.result
.value
)
1028 einfo ("%X%P: %s\n", tree
->assert_s
.message
);
1040 fold_trinary (tree
);
1045 case etree_provided
:
1046 if (tree
->assign
.dst
[0] == '.' && tree
->assign
.dst
[1] == 0)
1048 if (tree
->type
.node_class
!= etree_assign
)
1049 einfo (_("%F%P:%pS can not PROVIDE assignment to"
1050 " location counter\n"), tree
);
1051 if (expld
.phase
!= lang_first_phase_enum
)
1053 /* Notify the folder that this is an assignment to dot. */
1054 expld
.assigning_to_dot
= TRUE
;
1055 exp_fold_tree_1 (tree
->assign
.src
);
1056 expld
.assigning_to_dot
= FALSE
;
1058 /* If we are assigning to dot inside an output section
1059 arrange to keep the section, except for certain
1060 expressions that evaluate to zero. We ignore . = 0,
1061 . = . + 0, and . = ALIGN (. != 0 ? expr : 1).
1062 We can't ignore all expressions that evaluate to zero
1063 because an otherwise empty section might have padding
1064 added by an alignment expression that changes with
1065 relaxation. Such a section might have zero size
1066 before relaxation and so be stripped incorrectly. */
1067 if (expld
.phase
== lang_mark_phase_enum
1068 && expld
.section
!= bfd_abs_section_ptr
1069 && expld
.section
!= bfd_und_section_ptr
1070 && !(expld
.result
.valid_p
1071 && expld
.result
.value
== 0
1072 && (is_value (tree
->assign
.src
, 0)
1073 || is_sym_value (tree
->assign
.src
, 0)
1074 || is_dot_plus_0 (tree
->assign
.src
)
1075 || is_align_conditional (tree
->assign
.src
))))
1076 expld
.section
->flags
|= SEC_KEEP
;
1078 if (!expld
.result
.valid_p
1079 || expld
.section
== bfd_und_section_ptr
)
1081 if (expld
.phase
!= lang_mark_phase_enum
)
1082 einfo (_("%F%P:%pS invalid assignment to"
1083 " location counter\n"), tree
);
1085 else if (expld
.dotp
== NULL
)
1086 einfo (_("%F%P:%pS assignment to location counter"
1087 " invalid outside of SECTIONS\n"), tree
);
1089 /* After allocation, assignment to dot should not be
1090 done inside an output section since allocation adds a
1091 padding statement that effectively duplicates the
1093 else if (expld
.phase
<= lang_allocating_phase_enum
1094 || expld
.section
== bfd_abs_section_ptr
)
1098 nextdot
= expld
.result
.value
;
1099 if (expld
.result
.section
!= NULL
)
1100 nextdot
+= expld
.result
.section
->vma
;
1102 nextdot
+= expld
.section
->vma
;
1103 if (nextdot
< expld
.dot
1104 && expld
.section
!= bfd_abs_section_ptr
)
1105 einfo (_("%F%P:%pS cannot move location counter backwards"
1106 " (from %V to %V)\n"),
1107 tree
, expld
.dot
, nextdot
);
1110 expld
.dot
= nextdot
;
1111 *expld
.dotp
= nextdot
;
1116 memset (&expld
.result
, 0, sizeof (expld
.result
));
1120 struct bfd_link_hash_entry
*h
= NULL
;
1122 if (tree
->type
.node_class
== etree_provide
)
1124 h
= bfd_link_hash_lookup (link_info
.hash
, tree
->assign
.dst
,
1125 FALSE
, FALSE
, TRUE
);
1127 || !(h
->type
== bfd_link_hash_new
1128 || h
->type
== bfd_link_hash_undefined
1129 || h
->type
== bfd_link_hash_undefweak
1132 /* Do nothing. The symbol was never referenced, or
1133 was defined in some object file. Note that
1134 undefweak symbols are defined by PROVIDE. This
1135 is to support glibc use of __rela_iplt_start and
1136 similar weak references. */
1141 expld
.assign_name
= tree
->assign
.dst
;
1142 expld
.assign_src
= NULL
;
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
.phase
== lang_final_phase_enum
1154 || expld
.phase
== lang_fixed_phase_enum
1155 || expld
.assign_name
!= NULL
)
1157 if (tree
->type
.node_class
== etree_provide
)
1158 tree
->type
.node_class
= etree_provided
;
1162 h
= bfd_link_hash_lookup (link_info
.hash
, tree
->assign
.dst
,
1165 einfo (_("%F%P:%s: hash creation failed\n"),
1169 /* If the expression is not valid then fake a zero value. In
1170 the final phase any errors will already have been raised,
1171 in earlier phases we want to create this definition so
1172 that it can be seen by other expressions. */
1173 if (!expld
.result
.valid_p
1174 && h
->type
== bfd_link_hash_new
)
1176 expld
.result
.value
= 0;
1177 expld
.result
.section
= NULL
;
1178 expld
.result
.valid_p
= TRUE
;
1181 if (expld
.result
.valid_p
)
1183 if (expld
.result
.section
== NULL
)
1184 expld
.result
.section
= expld
.section
;
1185 if (!update_definedness (tree
->assign
.dst
, h
) && 0)
1187 /* Symbol was already defined. For now this error
1188 is disabled because it causes failures in the ld
1189 testsuite: ld-elf/var1, ld-scripts/defined5, and
1190 ld-scripts/pr14962. Some of these no doubt
1191 reflect scripts used in the wild. */
1192 (*link_info
.callbacks
->multiple_definition
)
1193 (&link_info
, h
, link_info
.output_bfd
,
1194 expld
.result
.section
, expld
.result
.value
);
1196 if (expld
.phase
== lang_fixed_phase_enum
)
1198 if (h
->type
== bfd_link_hash_defined
)
1200 expld
.result
.value
= h
->u
.def
.value
;
1201 expld
.result
.section
= h
->u
.def
.section
;
1206 h
->type
= bfd_link_hash_defined
;
1207 h
->u
.def
.value
= expld
.result
.value
;
1208 h
->u
.def
.section
= expld
.result
.section
;
1209 h
->linker_def
= ! tree
->assign
.type
.lineno
;
1210 h
->ldscript_def
= 1;
1211 h
->rel_from_abs
= expld
.rel_from_abs
;
1212 if (tree
->assign
.hidden
)
1213 bfd_link_hide_symbol (link_info
.output_bfd
,
1216 /* Copy the symbol type if this is an expression only
1217 referencing a single symbol. (If the expression
1218 contains ternary conditions, ignoring symbols on
1220 if (expld
.assign_src
!= NULL
1221 && (expld
.assign_src
1222 != (struct bfd_link_hash_entry
*) -1))
1223 bfd_copy_link_hash_symbol_type (link_info
.output_bfd
,
1224 h
, expld
.assign_src
);
1228 if (expld
.phase
!= lang_fixed_phase_enum
)
1229 expld
.assign_name
= NULL
;
1239 memset (&expld
.result
, 0, sizeof (expld
.result
));
1245 exp_fold_tree (etree_type
*tree
, asection
*current_section
, bfd_vma
*dotp
)
1247 expld
.rel_from_abs
= FALSE
;
1250 expld
.section
= current_section
;
1251 exp_fold_tree_1 (tree
);
1255 exp_fold_tree_no_dot (etree_type
*tree
)
1257 expld
.rel_from_abs
= FALSE
;
1260 expld
.section
= bfd_abs_section_ptr
;
1261 exp_fold_tree_1 (tree
);
1265 exp_value_fold (etree_type
*tree
)
1267 exp_fold_tree_no_dot (tree
);
1268 if (expld
.result
.valid_p
)
1270 tree
->type
.node_code
= INT
;
1271 tree
->value
.value
= expld
.result
.value
;
1272 tree
->value
.str
= NULL
;
1273 tree
->type
.node_class
= etree_value
;
1277 #define MAX(a, b) ((a) > (b) ? (a) : (b))
1280 exp_binop (int code
, etree_type
*lhs
, etree_type
*rhs
)
1282 etree_type
*new_e
= stat_alloc (MAX (sizeof (new_e
->binary
),
1283 sizeof (new_e
->value
)));
1284 new_e
->type
.node_code
= code
;
1285 new_e
->type
.filename
= lhs
->type
.filename
;
1286 new_e
->type
.lineno
= lhs
->type
.lineno
;
1287 new_e
->binary
.lhs
= lhs
;
1288 new_e
->binary
.rhs
= rhs
;
1289 new_e
->type
.node_class
= etree_binary
;
1290 if (lhs
->type
.node_class
== etree_value
1291 && rhs
->type
.node_class
== etree_value
1293 && code
!= DATA_SEGMENT_ALIGN
1294 && code
!= DATA_SEGMENT_RELRO_END
)
1295 exp_value_fold (new_e
);
1300 exp_trinop (int code
, etree_type
*cond
, etree_type
*lhs
, etree_type
*rhs
)
1302 etree_type
*new_e
= stat_alloc (MAX (sizeof (new_e
->trinary
),
1303 sizeof (new_e
->value
)));
1304 new_e
->type
.node_code
= code
;
1305 new_e
->type
.filename
= cond
->type
.filename
;
1306 new_e
->type
.lineno
= cond
->type
.lineno
;
1307 new_e
->trinary
.lhs
= lhs
;
1308 new_e
->trinary
.cond
= cond
;
1309 new_e
->trinary
.rhs
= rhs
;
1310 new_e
->type
.node_class
= etree_trinary
;
1311 if (cond
->type
.node_class
== etree_value
1312 && lhs
->type
.node_class
== etree_value
1313 && rhs
->type
.node_class
== etree_value
)
1314 exp_value_fold (new_e
);
1319 exp_unop (int code
, etree_type
*child
)
1321 etree_type
*new_e
= stat_alloc (MAX (sizeof (new_e
->unary
),
1322 sizeof (new_e
->value
)));
1323 new_e
->unary
.type
.node_code
= code
;
1324 new_e
->unary
.type
.filename
= child
->type
.filename
;
1325 new_e
->unary
.type
.lineno
= child
->type
.lineno
;
1326 new_e
->unary
.child
= child
;
1327 new_e
->unary
.type
.node_class
= etree_unary
;
1328 if (child
->type
.node_class
== etree_value
1332 && code
!= DATA_SEGMENT_END
)
1333 exp_value_fold (new_e
);
1338 exp_nameop (int code
, const char *name
)
1340 etree_type
*new_e
= stat_alloc (sizeof (new_e
->name
));
1342 new_e
->name
.type
.node_code
= code
;
1343 new_e
->name
.type
.filename
= ldlex_filename ();
1344 new_e
->name
.type
.lineno
= lineno
;
1345 new_e
->name
.name
= name
;
1346 new_e
->name
.type
.node_class
= etree_name
;
1352 exp_assop (const char *dst
,
1354 enum node_tree_enum
class,
1359 n
= stat_alloc (sizeof (n
->assign
));
1360 n
->assign
.type
.node_code
= '=';
1361 n
->assign
.type
.filename
= src
->type
.filename
;
1362 n
->assign
.type
.lineno
= src
->type
.lineno
;
1363 n
->assign
.type
.node_class
= class;
1364 n
->assign
.src
= src
;
1365 n
->assign
.dst
= dst
;
1366 n
->assign
.hidden
= hidden
;
1370 /* Handle linker script assignments and HIDDEN. */
1373 exp_assign (const char *dst
, etree_type
*src
, bfd_boolean hidden
)
1375 return exp_assop (dst
, src
, etree_assign
, hidden
);
1378 /* Handle --defsym command-line option. */
1381 exp_defsym (const char *dst
, etree_type
*src
)
1383 return exp_assop (dst
, src
, etree_assign
, FALSE
);
1386 /* Handle PROVIDE. */
1389 exp_provide (const char *dst
, etree_type
*src
, bfd_boolean hidden
)
1391 return exp_assop (dst
, src
, etree_provide
, hidden
);
1394 /* Handle ASSERT. */
1397 exp_assert (etree_type
*exp
, const char *message
)
1401 n
= stat_alloc (sizeof (n
->assert_s
));
1402 n
->assert_s
.type
.node_code
= '!';
1403 n
->assert_s
.type
.filename
= exp
->type
.filename
;
1404 n
->assert_s
.type
.lineno
= exp
->type
.lineno
;
1405 n
->assert_s
.type
.node_class
= etree_assert
;
1406 n
->assert_s
.child
= exp
;
1407 n
->assert_s
.message
= message
;
1412 exp_print_tree (etree_type
*tree
)
1414 bfd_boolean function_like
;
1416 if (config
.map_file
== NULL
)
1417 config
.map_file
= stderr
;
1421 minfo ("NULL TREE\n");
1425 switch (tree
->type
.node_class
)
1428 minfo ("0x%v", tree
->value
.value
);
1431 if (tree
->rel
.section
->owner
!= NULL
)
1432 minfo ("%pB:", tree
->rel
.section
->owner
);
1433 minfo ("%s+0x%v", tree
->rel
.section
->name
, tree
->rel
.value
);
1436 fputs (tree
->assign
.dst
, config
.map_file
);
1437 exp_print_token (tree
->type
.node_code
, TRUE
);
1438 exp_print_tree (tree
->assign
.src
);
1441 case etree_provided
:
1442 fprintf (config
.map_file
, "PROVIDE (%s = ", tree
->assign
.dst
);
1443 exp_print_tree (tree
->assign
.src
);
1444 fputc (')', config
.map_file
);
1447 function_like
= FALSE
;
1448 switch (tree
->type
.node_code
)
1453 case DATA_SEGMENT_ALIGN
:
1454 case DATA_SEGMENT_RELRO_END
:
1455 function_like
= TRUE
;
1458 /* Special handling because arguments are in reverse order and
1459 the segment name is quoted. */
1460 exp_print_token (tree
->type
.node_code
, FALSE
);
1461 fputs (" (\"", config
.map_file
);
1462 exp_print_tree (tree
->binary
.rhs
);
1463 fputs ("\", ", config
.map_file
);
1464 exp_print_tree (tree
->binary
.lhs
);
1465 fputc (')', config
.map_file
);
1470 exp_print_token (tree
->type
.node_code
, FALSE
);
1471 fputc (' ', config
.map_file
);
1473 fputc ('(', config
.map_file
);
1474 exp_print_tree (tree
->binary
.lhs
);
1476 fprintf (config
.map_file
, ", ");
1478 exp_print_token (tree
->type
.node_code
, TRUE
);
1479 exp_print_tree (tree
->binary
.rhs
);
1480 fputc (')', config
.map_file
);
1483 exp_print_tree (tree
->trinary
.cond
);
1484 fputc ('?', config
.map_file
);
1485 exp_print_tree (tree
->trinary
.lhs
);
1486 fputc (':', config
.map_file
);
1487 exp_print_tree (tree
->trinary
.rhs
);
1490 exp_print_token (tree
->unary
.type
.node_code
, FALSE
);
1491 if (tree
->unary
.child
)
1493 fprintf (config
.map_file
, " (");
1494 exp_print_tree (tree
->unary
.child
);
1495 fputc (')', config
.map_file
);
1500 fprintf (config
.map_file
, "ASSERT (");
1501 exp_print_tree (tree
->assert_s
.child
);
1502 fprintf (config
.map_file
, ", %s)", tree
->assert_s
.message
);
1506 if (tree
->type
.node_code
== NAME
)
1507 fputs (tree
->name
.name
, config
.map_file
);
1510 exp_print_token (tree
->type
.node_code
, FALSE
);
1511 if (tree
->name
.name
)
1512 fprintf (config
.map_file
, " (%s)", tree
->name
.name
);
1522 exp_get_vma (etree_type
*tree
, bfd_vma def
, char *name
)
1526 exp_fold_tree_no_dot (tree
);
1527 if (expld
.result
.valid_p
)
1528 return expld
.result
.value
;
1529 else if (name
!= NULL
&& expld
.phase
!= lang_mark_phase_enum
)
1530 einfo (_("%F%P:%pS: nonconstant expression for %s\n"),
1536 /* Return the smallest non-negative integer such that two raised to
1537 that power is at least as large as the vma evaluated at TREE, if
1538 TREE is a non-NULL expression that can be resolved. If TREE is
1539 NULL or cannot be resolved, return -1. */
1542 exp_get_power (etree_type
*tree
, char *name
)
1544 bfd_vma x
= exp_get_vma (tree
, -1, name
);
1548 if (x
== (bfd_vma
) -1)
1551 for (n
= 0, p2
= 1; p2
< x
; ++n
, p2
<<= 1)
1559 exp_get_fill (etree_type
*tree
, fill_type
*def
, char *name
)
1568 exp_fold_tree_no_dot (tree
);
1569 if (!expld
.result
.valid_p
)
1571 if (name
!= NULL
&& expld
.phase
!= lang_mark_phase_enum
)
1572 einfo (_("%F%P:%pS: nonconstant expression for %s\n"),
1577 if (expld
.result
.str
!= NULL
&& (len
= strlen (expld
.result
.str
)) != 0)
1581 fill
= (fill_type
*) xmalloc ((len
+ 1) / 2 + sizeof (*fill
) - 1);
1582 fill
->size
= (len
+ 1) / 2;
1584 s
= (unsigned char *) expld
.result
.str
;
1592 digit
= (digit
- 'A' + '0' + 10) & 0xf;
1606 fill
= (fill_type
*) xmalloc (4 + sizeof (*fill
) - 1);
1607 val
= expld
.result
.value
;
1608 fill
->data
[0] = (val
>> 24) & 0xff;
1609 fill
->data
[1] = (val
>> 16) & 0xff;
1610 fill
->data
[2] = (val
>> 8) & 0xff;
1611 fill
->data
[3] = (val
>> 0) & 0xff;
1618 exp_get_abs_int (etree_type
*tree
, int def
, char *name
)
1622 exp_fold_tree_no_dot (tree
);
1624 if (expld
.result
.valid_p
)
1626 if (expld
.result
.section
!= NULL
)
1627 expld
.result
.value
+= expld
.result
.section
->vma
;
1628 return expld
.result
.value
;
1630 else if (name
!= NULL
&& expld
.phase
!= lang_mark_phase_enum
)
1632 einfo (_("%F%P:%pS: nonconstant expression for %s\n"),
1640 align_n (bfd_vma value
, bfd_vma align
)
1645 value
= (value
+ align
- 1) / align
;
1646 return value
* align
;
1652 /* The value "13" is ad-hoc, somewhat related to the expected number of
1653 assignments in a linker script. */
1654 if (!bfd_hash_table_init_n (&definedness_table
,
1655 definedness_newfunc
,
1656 sizeof (struct definedness_hash_entry
),
1658 einfo (_("%F%P: can not create hash table: %E\n"));
1661 /* Convert absolute symbols defined by a script from "dot" (also
1662 SEGMENT_START or ORIGIN) outside of an output section statement,
1663 to section relative. */
1666 set_sym_sections (struct bfd_hash_entry
*bh
, void *inf ATTRIBUTE_UNUSED
)
1668 struct definedness_hash_entry
*def
= (struct definedness_hash_entry
*) bh
;
1669 if (def
->final_sec
!= bfd_abs_section_ptr
)
1671 struct bfd_link_hash_entry
*h
;
1672 h
= bfd_link_hash_lookup (link_info
.hash
, bh
->string
,
1673 FALSE
, FALSE
, TRUE
);
1675 && h
->type
== bfd_link_hash_defined
1676 && h
->u
.def
.section
== bfd_abs_section_ptr
)
1678 h
->u
.def
.value
-= def
->final_sec
->vma
;
1679 h
->u
.def
.section
= def
->final_sec
;
1686 ldexp_finalize_syms (void)
1688 bfd_hash_traverse (&definedness_table
, set_sym_sections
, NULL
);
1694 bfd_hash_table_free (&definedness_table
);