1 /* This module handles expression trees.
2 Copyright (C) 1991-2021 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 bool 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
328 && !bfd_is_abs_section (h
->u
.def
.section
)
333 defentry
->iteration
= lang_statement_iteration
;
334 defentry
->final_sec
= bfd_abs_section_ptr
;
335 if (expld
.phase
== lang_final_phase_enum
336 && expld
.rel_from_abs
337 && expld
.result
.section
== bfd_abs_section_ptr
)
338 defentry
->final_sec
= section_for_dot ();
343 fold_segment_end (seg_align_type
*seg
)
345 if (expld
.phase
== lang_first_phase_enum
346 || expld
.section
!= bfd_abs_section_ptr
)
348 expld
.result
.valid_p
= false;
350 else if (seg
->phase
== exp_seg_align_seen
351 || seg
->phase
== exp_seg_relro_seen
)
353 seg
->phase
= exp_seg_end_seen
;
354 seg
->end
= expld
.result
.value
;
356 else if (seg
->phase
== exp_seg_done
357 || seg
->phase
== exp_seg_adjust
358 || seg
->phase
== exp_seg_relro_adjust
)
363 expld
.result
.valid_p
= false;
367 fold_unary (etree_type
*tree
)
369 exp_fold_tree_1 (tree
->unary
.child
);
370 if (expld
.result
.valid_p
)
372 switch (tree
->type
.node_code
)
375 if (expld
.phase
!= lang_first_phase_enum
)
376 new_rel_from_abs (align_n (expld
.dot
, expld
.result
.value
));
378 expld
.result
.valid_p
= false;
390 expld
.result
.value
= ~expld
.result
.value
;
394 expld
.result
.value
= !expld
.result
.value
;
398 expld
.result
.value
= -expld
.result
.value
;
402 /* Return next place aligned to value. */
403 if (expld
.phase
!= lang_first_phase_enum
)
406 expld
.result
.value
= align_n (expld
.dot
, expld
.result
.value
);
409 expld
.result
.valid_p
= false;
412 case DATA_SEGMENT_END
:
413 fold_segment_end (&expld
.dataseg
);
423 /* Arithmetic operators, bitwise AND, bitwise OR and XOR keep the
424 section of one of their operands only when the other operand is a
425 plain number. Losing the section when operating on two symbols,
426 ie. a result of a plain number, is required for subtraction and
427 XOR. It's justifiable for the other operations on the grounds that
428 adding, multiplying etc. two section relative values does not
429 really make sense unless they are just treated as numbers.
430 The same argument could be made for many expressions involving one
431 symbol and a number. For example, "1 << x" and "100 / x" probably
432 should not be given the section of x. The trouble is that if we
433 fuss about such things the rules become complex and it is onerous
434 to document ld expression evaluation. */
436 arith_result_section (const etree_value_type
*lhs
)
438 if (expld
.result
.section
== lhs
->section
)
440 if (expld
.section
== bfd_abs_section_ptr
441 && !config
.sane_expr
)
442 /* Duplicate the insanity in exp_fold_tree_1 case etree_value. */
443 expld
.result
.section
= bfd_abs_section_ptr
;
445 expld
.result
.section
= NULL
;
450 fold_segment_align (seg_align_type
*seg
, etree_value_type
*lhs
)
452 seg
->relro
= exp_seg_relro_start
;
453 if (expld
.phase
== lang_first_phase_enum
454 || expld
.section
!= bfd_abs_section_ptr
)
455 expld
.result
.valid_p
= false;
458 bfd_vma maxpage
= lhs
->value
;
459 bfd_vma commonpage
= expld
.result
.value
;
461 expld
.result
.value
= align_n (expld
.dot
, maxpage
);
462 if (seg
->phase
== exp_seg_relro_adjust
)
463 expld
.result
.value
= seg
->base
;
464 else if (seg
->phase
== exp_seg_adjust
)
466 if (commonpage
< maxpage
)
467 expld
.result
.value
+= ((expld
.dot
+ commonpage
- 1)
468 & (maxpage
- commonpage
));
472 expld
.result
.value
+= expld
.dot
& (maxpage
- 1);
473 if (seg
->phase
== exp_seg_done
)
477 else if (seg
->phase
== exp_seg_none
)
479 seg
->phase
= exp_seg_align_seen
;
480 seg
->base
= expld
.result
.value
;
481 seg
->pagesize
= commonpage
;
482 seg
->maxpagesize
= maxpage
;
486 expld
.result
.valid_p
= false;
492 fold_segment_relro_end (seg_align_type
*seg
, etree_value_type
*lhs
)
494 /* Operands swapped! XXX_SEGMENT_RELRO_END(offset,exp) has offset
495 in expld.result and exp in lhs. */
496 seg
->relro
= exp_seg_relro_end
;
497 seg
->relro_offset
= expld
.result
.value
;
498 if (expld
.phase
== lang_first_phase_enum
499 || expld
.section
!= bfd_abs_section_ptr
)
500 expld
.result
.valid_p
= false;
501 else if (seg
->phase
== exp_seg_align_seen
502 || seg
->phase
== exp_seg_adjust
503 || seg
->phase
== exp_seg_relro_adjust
504 || seg
->phase
== exp_seg_done
)
506 if (seg
->phase
== exp_seg_align_seen
507 || seg
->phase
== exp_seg_relro_adjust
)
508 seg
->relro_end
= lhs
->value
+ expld
.result
.value
;
510 if (seg
->phase
== exp_seg_relro_adjust
511 && (seg
->relro_end
& (seg
->pagesize
- 1)))
513 seg
->relro_end
+= seg
->pagesize
- 1;
514 seg
->relro_end
&= ~(seg
->pagesize
- 1);
515 expld
.result
.value
= seg
->relro_end
- expld
.result
.value
;
518 expld
.result
.value
= lhs
->value
;
520 if (seg
->phase
== exp_seg_align_seen
)
521 seg
->phase
= exp_seg_relro_seen
;
524 expld
.result
.valid_p
= false;
528 fold_binary (etree_type
*tree
)
530 etree_value_type lhs
;
531 exp_fold_tree_1 (tree
->binary
.lhs
);
533 /* The SEGMENT_START operator is special because its first
534 operand is a string, not the name of a symbol. Note that the
535 operands have been swapped, so binary.lhs is second (default)
536 operand, binary.rhs is first operand. */
537 if (expld
.result
.valid_p
&& tree
->type
.node_code
== SEGMENT_START
)
539 bfd_vma value
= expld
.result
.value
;
540 const char *segment_name
;
543 /* Check to see if the user has overridden the default
545 segment_name
= tree
->binary
.rhs
->name
.name
;
546 for (seg
= segments
; seg
; seg
= seg
->next
)
547 if (strcmp (seg
->name
, segment_name
) == 0)
550 && config
.magic_demand_paged
551 && link_info
.maxpagesize
!= 0
552 && (seg
->value
% link_info
.maxpagesize
) != 0)
553 einfo (_("%P: warning: address of `%s' "
554 "isn't multiple of maximum page size\n"),
560 new_rel_from_abs (value
);
565 exp_fold_tree_1 (tree
->binary
.rhs
);
566 expld
.result
.valid_p
&= lhs
.valid_p
;
568 if (expld
.result
.valid_p
)
570 if (lhs
.section
!= expld
.result
.section
)
572 /* If the values are from different sections, and neither is
573 just a number, make both the source arguments absolute. */
574 if (expld
.result
.section
!= NULL
575 && lhs
.section
!= NULL
)
578 lhs
.value
+= lhs
.section
->vma
;
579 lhs
.section
= bfd_abs_section_ptr
;
582 /* If the rhs is just a number, keep the lhs section. */
583 else if (expld
.result
.section
== NULL
)
585 expld
.result
.section
= lhs
.section
;
586 /* Make this NULL so that we know one of the operands
587 was just a number, for later tests. */
591 /* At this point we know that both operands have the same
592 section, or at least one of them is a plain number. */
594 switch (tree
->type
.node_code
)
598 expld.result.value = lhs.value y expld.result.value; \
599 arith_result_section (&lhs); \
602 /* Comparison operators, logical AND, and logical OR always
603 return a plain number. */
606 expld.result.value = lhs.value y expld.result.value; \
607 expld.result.section = NULL; \
628 if (expld
.result
.value
!= 0)
629 expld
.result
.value
= ((bfd_signed_vma
) lhs
.value
630 % (bfd_signed_vma
) expld
.result
.value
);
631 else if (expld
.phase
!= lang_mark_phase_enum
)
632 einfo (_("%F%P:%pS %% by zero\n"), tree
->binary
.rhs
);
633 arith_result_section (&lhs
);
637 if (expld
.result
.value
!= 0)
638 expld
.result
.value
= ((bfd_signed_vma
) lhs
.value
639 / (bfd_signed_vma
) expld
.result
.value
);
640 else if (expld
.phase
!= lang_mark_phase_enum
)
641 einfo (_("%F%P:%pS / by zero\n"), tree
->binary
.rhs
);
642 arith_result_section (&lhs
);
646 if (lhs
.value
> expld
.result
.value
)
647 expld
.result
.value
= lhs
.value
;
651 if (lhs
.value
< expld
.result
.value
)
652 expld
.result
.value
= lhs
.value
;
656 expld
.result
.value
= align_n (lhs
.value
, expld
.result
.value
);
659 case DATA_SEGMENT_ALIGN
:
660 fold_segment_align (&expld
.dataseg
, &lhs
);
663 case DATA_SEGMENT_RELRO_END
:
664 fold_segment_relro_end (&expld
.dataseg
, &lhs
);
674 fold_trinary (etree_type
*tree
)
676 struct bfd_link_hash_entry
*save
= expld
.assign_src
;
678 exp_fold_tree_1 (tree
->trinary
.cond
);
679 expld
.assign_src
= save
;
680 if (expld
.result
.valid_p
)
681 exp_fold_tree_1 (expld
.result
.value
683 : tree
->trinary
.rhs
);
687 fold_name (etree_type
*tree
)
689 struct bfd_link_hash_entry
*h
;
690 struct definedness_hash_entry
*def
;
692 memset (&expld
.result
, 0, sizeof (expld
.result
));
694 switch (tree
->type
.node_code
)
697 link_info
.load_phdrs
= 1;
698 if (expld
.phase
!= lang_first_phase_enum
)
700 bfd_vma hdr_size
= 0;
701 /* Don't find the real header size if only marking sections;
702 The bfd function may cache incorrect data. */
703 if (expld
.phase
!= lang_mark_phase_enum
)
704 hdr_size
= (bfd_sizeof_headers (link_info
.output_bfd
, &link_info
)
705 / bfd_octets_per_byte (link_info
.output_bfd
, NULL
));
706 new_number (hdr_size
);
711 h
= bfd_wrapped_link_hash_lookup (link_info
.output_bfd
,
715 new_number (h
!= NULL
716 && (h
->type
== bfd_link_hash_defined
717 || h
->type
== bfd_link_hash_defweak
718 || h
->type
== bfd_link_hash_common
)
720 || (def
= symbol_defined (tree
->name
.name
)) == NULL
722 || def
->iteration
== (lang_statement_iteration
& 255)));
726 if (tree
->name
.name
[0] == '.' && tree
->name
.name
[1] == 0)
727 new_rel_from_abs (expld
.dot
);
730 h
= bfd_wrapped_link_hash_lookup (link_info
.output_bfd
,
736 if (expld
.phase
!= lang_first_phase_enum
)
737 einfo (_("%F%P: bfd_link_hash_lookup failed: %E\n"));
739 else if (h
->type
== bfd_link_hash_defined
740 || h
->type
== bfd_link_hash_defweak
)
742 asection
*output_section
;
744 output_section
= h
->u
.def
.section
->output_section
;
745 if (output_section
== NULL
)
747 if (expld
.phase
<= lang_mark_phase_enum
)
748 new_rel (h
->u
.def
.value
, h
->u
.def
.section
);
750 einfo (_("%X%P:%pS: unresolvable symbol `%s'"
751 " referenced in expression\n"),
752 tree
, tree
->name
.name
);
754 else if (output_section
== bfd_abs_section_ptr
755 && (expld
.section
!= bfd_abs_section_ptr
756 || config
.sane_expr
))
757 new_number (h
->u
.def
.value
+ h
->u
.def
.section
->output_offset
);
759 new_rel (h
->u
.def
.value
+ h
->u
.def
.section
->output_offset
,
762 else if (expld
.phase
== lang_final_phase_enum
763 || (expld
.phase
!= lang_mark_phase_enum
764 && expld
.assigning_to_dot
))
765 einfo (_("%F%P:%pS: undefined symbol `%s'"
766 " referenced in expression\n"),
767 tree
, tree
->name
.name
);
768 else if (h
->type
== bfd_link_hash_new
)
770 h
->type
= bfd_link_hash_undefined
;
771 h
->u
.undef
.abfd
= NULL
;
772 if (h
->u
.undef
.next
== NULL
&& h
!= link_info
.hash
->undefs_tail
)
773 bfd_link_add_undef (link_info
.hash
, h
);
775 if (expld
.assign_src
== NULL
)
776 expld
.assign_src
= h
;
778 expld
.assign_src
= (struct bfd_link_hash_entry
*) - 1;
780 /* Self-assignment is only allowed for absolute symbols
781 defined in a linker script. */
782 if (expld
.assign_name
!= NULL
783 && strcmp (expld
.assign_name
, tree
->name
.name
) == 0
785 && (h
->type
== bfd_link_hash_defined
786 || h
->type
== bfd_link_hash_defweak
)
787 && h
->u
.def
.section
== bfd_abs_section_ptr
788 && (def
= symbol_defined (tree
->name
.name
)) != NULL
789 && def
->iteration
== (lang_statement_iteration
& 255)))
790 expld
.assign_name
= NULL
;
795 if (expld
.phase
!= lang_first_phase_enum
)
797 lang_output_section_statement_type
*os
;
799 os
= lang_output_section_find (tree
->name
.name
);
802 if (expld
.phase
== lang_final_phase_enum
)
803 einfo (_("%F%P:%pS: undefined section `%s'"
804 " referenced in expression\n"),
805 tree
, tree
->name
.name
);
807 else if (os
->processed_vma
)
808 new_rel (0, os
->bfd_section
);
813 if (expld
.phase
!= lang_first_phase_enum
)
815 lang_output_section_statement_type
*os
;
817 os
= lang_output_section_find (tree
->name
.name
);
820 if (expld
.phase
== lang_final_phase_enum
)
821 einfo (_("%F%P:%pS: undefined section `%s'"
822 " referenced in expression\n"),
823 tree
, tree
->name
.name
);
825 else if (os
->processed_lma
)
827 if (os
->load_base
== NULL
)
828 new_abs (os
->bfd_section
->lma
);
831 exp_fold_tree_1 (os
->load_base
);
832 if (expld
.result
.valid_p
)
841 if (expld
.phase
!= lang_first_phase_enum
)
843 lang_output_section_statement_type
*os
;
845 os
= lang_output_section_find (tree
->name
.name
);
848 if (expld
.phase
== lang_final_phase_enum
)
849 einfo (_("%F%P:%pS: undefined section `%s'"
850 " referenced in expression\n"),
851 tree
, tree
->name
.name
);
854 else if (os
->bfd_section
!= NULL
)
858 if (tree
->type
.node_code
== SIZEOF
)
859 val
= (os
->bfd_section
->size
860 / bfd_octets_per_byte (link_info
.output_bfd
,
863 val
= (bfd_vma
)1 << os
->bfd_section
->alignment_power
;
874 lang_memory_region_type
*mem
;
876 mem
= lang_memory_region_lookup (tree
->name
.name
, false);
878 new_number (mem
->length
);
880 einfo (_("%F%P:%pS: undefined MEMORY region `%s'"
881 " referenced in expression\n"),
882 tree
, tree
->name
.name
);
888 lang_memory_region_type
*mem
;
890 mem
= lang_memory_region_lookup (tree
->name
.name
, false);
892 new_rel_from_abs (mem
->origin
);
894 einfo (_("%F%P:%pS: undefined MEMORY region `%s'"
895 " referenced in expression\n"),
896 tree
, tree
->name
.name
);
901 if (strcmp (tree
->name
.name
, "MAXPAGESIZE") == 0)
902 new_number (link_info
.maxpagesize
);
903 else if (strcmp (tree
->name
.name
, "COMMONPAGESIZE") == 0)
904 new_number (link_info
.commonpagesize
);
906 einfo (_("%F%P:%pS: unknown constant `%s' referenced in expression\n"),
907 tree
, tree
->name
.name
);
916 /* Return true if TREE is '.'. */
919 is_dot (const etree_type
*tree
)
921 return (tree
->type
.node_class
== etree_name
922 && tree
->type
.node_code
== NAME
923 && tree
->name
.name
[0] == '.'
924 && tree
->name
.name
[1] == 0);
927 /* Return true if TREE is a constant equal to VAL. */
930 is_value (const etree_type
*tree
, bfd_vma val
)
932 return (tree
->type
.node_class
== etree_value
933 && tree
->value
.value
== val
);
936 /* Return true if TREE is an absolute symbol equal to VAL defined in
940 is_sym_value (const etree_type
*tree
, bfd_vma val
)
942 struct bfd_link_hash_entry
*h
;
943 struct definedness_hash_entry
*def
;
945 return (tree
->type
.node_class
== etree_name
946 && tree
->type
.node_code
== NAME
947 && (def
= symbol_defined (tree
->name
.name
)) != NULL
948 && def
->iteration
== (lang_statement_iteration
& 255)
949 && (h
= bfd_wrapped_link_hash_lookup (link_info
.output_bfd
,
952 false, false, true)) != NULL
954 && h
->type
== bfd_link_hash_defined
955 && h
->u
.def
.section
== bfd_abs_section_ptr
956 && h
->u
.def
.value
== val
);
959 /* Return true if TREE is ". != 0". */
962 is_dot_ne_0 (const etree_type
*tree
)
964 return (tree
->type
.node_class
== etree_binary
965 && tree
->type
.node_code
== NE
966 && is_dot (tree
->binary
.lhs
)
967 && is_value (tree
->binary
.rhs
, 0));
970 /* Return true if TREE is ". = . + 0" or ". = . + sym" where sym is an
971 absolute constant with value 0 defined in a linker script. */
974 is_dot_plus_0 (const etree_type
*tree
)
976 return (tree
->type
.node_class
== etree_binary
977 && tree
->type
.node_code
== '+'
978 && is_dot (tree
->binary
.lhs
)
979 && (is_value (tree
->binary
.rhs
, 0)
980 || is_sym_value (tree
->binary
.rhs
, 0)));
983 /* Return true if TREE is "ALIGN (. != 0 ? some_expression : 1)". */
986 is_align_conditional (const etree_type
*tree
)
988 if (tree
->type
.node_class
== etree_unary
989 && tree
->type
.node_code
== ALIGN_K
)
991 tree
= tree
->unary
.child
;
992 return (tree
->type
.node_class
== etree_trinary
993 && is_dot_ne_0 (tree
->trinary
.cond
)
994 && is_value (tree
->trinary
.rhs
, 1));
1000 exp_fold_tree_1 (etree_type
*tree
)
1004 memset (&expld
.result
, 0, sizeof (expld
.result
));
1008 switch (tree
->type
.node_class
)
1011 if (expld
.section
== bfd_abs_section_ptr
1012 && !config
.sane_expr
)
1013 new_abs (tree
->value
.value
);
1015 new_number (tree
->value
.value
);
1016 expld
.result
.str
= tree
->value
.str
;
1020 if (expld
.phase
!= lang_first_phase_enum
)
1022 asection
*output_section
= tree
->rel
.section
->output_section
;
1023 new_rel (tree
->rel
.value
+ tree
->rel
.section
->output_offset
,
1027 memset (&expld
.result
, 0, sizeof (expld
.result
));
1031 exp_fold_tree_1 (tree
->assert_s
.child
);
1032 if (expld
.phase
== lang_final_phase_enum
&& !expld
.result
.value
)
1033 einfo ("%X%P: %s\n", tree
->assert_s
.message
);
1045 fold_trinary (tree
);
1050 case etree_provided
:
1051 if (tree
->assign
.dst
[0] == '.' && tree
->assign
.dst
[1] == 0)
1053 if (tree
->type
.node_class
!= etree_assign
)
1054 einfo (_("%F%P:%pS can not PROVIDE assignment to"
1055 " location counter\n"), tree
);
1056 if (expld
.phase
!= lang_first_phase_enum
)
1058 /* Notify the folder that this is an assignment to dot. */
1059 expld
.assigning_to_dot
= true;
1060 exp_fold_tree_1 (tree
->assign
.src
);
1061 expld
.assigning_to_dot
= false;
1063 /* If we are assigning to dot inside an output section
1064 arrange to keep the section, except for certain
1065 expressions that evaluate to zero. We ignore . = 0,
1066 . = . + 0, and . = ALIGN (. != 0 ? expr : 1).
1067 We can't ignore all expressions that evaluate to zero
1068 because an otherwise empty section might have padding
1069 added by an alignment expression that changes with
1070 relaxation. Such a section might have zero size
1071 before relaxation and so be stripped incorrectly. */
1072 if (expld
.phase
== lang_mark_phase_enum
1073 && expld
.section
!= bfd_abs_section_ptr
1074 && expld
.section
!= bfd_und_section_ptr
1075 && !(expld
.result
.valid_p
1076 && expld
.result
.value
== 0
1077 && (is_value (tree
->assign
.src
, 0)
1078 || is_sym_value (tree
->assign
.src
, 0)
1079 || is_dot_plus_0 (tree
->assign
.src
)
1080 || is_align_conditional (tree
->assign
.src
))))
1081 expld
.section
->flags
|= SEC_KEEP
;
1083 if (!expld
.result
.valid_p
1084 || expld
.section
== bfd_und_section_ptr
)
1086 if (expld
.phase
!= lang_mark_phase_enum
)
1087 einfo (_("%F%P:%pS invalid assignment to"
1088 " location counter\n"), tree
);
1090 else if (expld
.dotp
== NULL
)
1091 einfo (_("%F%P:%pS assignment to location counter"
1092 " invalid outside of SECTIONS\n"), tree
);
1094 /* After allocation, assignment to dot should not be
1095 done inside an output section since allocation adds a
1096 padding statement that effectively duplicates the
1098 else if (expld
.phase
<= lang_allocating_phase_enum
1099 || expld
.section
== bfd_abs_section_ptr
)
1103 nextdot
= expld
.result
.value
;
1104 if (expld
.result
.section
!= NULL
)
1105 nextdot
+= expld
.result
.section
->vma
;
1107 nextdot
+= expld
.section
->vma
;
1108 if (nextdot
< expld
.dot
1109 && expld
.section
!= bfd_abs_section_ptr
)
1110 einfo (_("%F%P:%pS cannot move location counter backwards"
1111 " (from %V to %V)\n"),
1112 tree
, expld
.dot
, nextdot
);
1115 expld
.dot
= nextdot
;
1116 *expld
.dotp
= nextdot
;
1121 memset (&expld
.result
, 0, sizeof (expld
.result
));
1125 struct bfd_link_hash_entry
*h
= NULL
;
1127 if (tree
->type
.node_class
== etree_provide
)
1129 h
= bfd_link_hash_lookup (link_info
.hash
, tree
->assign
.dst
,
1130 false, false, true);
1132 || !(h
->type
== bfd_link_hash_new
1133 || h
->type
== bfd_link_hash_undefined
1134 || h
->type
== bfd_link_hash_undefweak
1137 /* Do nothing. The symbol was never referenced, or
1138 was defined in some object file. Note that
1139 undefweak symbols are defined by PROVIDE. This
1140 is to support glibc use of __rela_iplt_start and
1141 similar weak references. */
1146 expld
.assign_name
= tree
->assign
.dst
;
1147 expld
.assign_src
= NULL
;
1148 exp_fold_tree_1 (tree
->assign
.src
);
1149 /* expld.assign_name remaining equal to tree->assign.dst
1150 below indicates the evaluation of tree->assign.src did
1151 not use the value of tree->assign.dst. We don't allow
1152 self assignment until the final phase for two reasons:
1153 1) Expressions are evaluated multiple times. With
1154 relaxation, the number of times may vary.
1155 2) Section relative symbol values cannot be correctly
1156 converted to absolute values, as is required by many
1157 expressions, until final section sizing is complete. */
1158 if (expld
.phase
== lang_final_phase_enum
1159 || expld
.phase
== lang_fixed_phase_enum
1160 || expld
.assign_name
!= NULL
)
1162 if (tree
->type
.node_class
== etree_provide
)
1163 tree
->type
.node_class
= etree_provided
;
1167 h
= bfd_link_hash_lookup (link_info
.hash
, tree
->assign
.dst
,
1170 einfo (_("%F%P:%s: hash creation failed\n"),
1174 /* If the expression is not valid then fake a zero value. In
1175 the final phase any errors will already have been raised,
1176 in earlier phases we want to create this definition so
1177 that it can be seen by other expressions. */
1178 if (!expld
.result
.valid_p
1179 && h
->type
== bfd_link_hash_new
)
1181 expld
.result
.value
= 0;
1182 expld
.result
.section
= NULL
;
1183 expld
.result
.valid_p
= true;
1186 if (expld
.result
.valid_p
)
1188 if (expld
.result
.section
== NULL
)
1189 expld
.result
.section
= expld
.section
;
1190 if (!update_definedness (tree
->assign
.dst
, h
)
1191 && expld
.assign_name
!= NULL
)
1193 /* Symbol was already defined, and the script isn't
1194 modifying the symbol value for some reason as in
1195 ld-elf/var1 and ld-scripts/pr14962.
1196 For now this is only a warning. */
1197 unsigned int warn
= link_info
.warn_multiple_definition
;
1198 link_info
.warn_multiple_definition
= 1;
1199 (*link_info
.callbacks
->multiple_definition
)
1200 (&link_info
, h
, link_info
.output_bfd
,
1201 expld
.result
.section
, expld
.result
.value
);
1202 link_info
.warn_multiple_definition
= warn
;
1204 if (expld
.phase
== lang_fixed_phase_enum
)
1206 if (h
->type
== bfd_link_hash_defined
)
1208 expld
.result
.value
= h
->u
.def
.value
;
1209 expld
.result
.section
= h
->u
.def
.section
;
1214 h
->type
= bfd_link_hash_defined
;
1215 h
->u
.def
.value
= expld
.result
.value
;
1216 h
->u
.def
.section
= expld
.result
.section
;
1217 h
->linker_def
= ! tree
->assign
.type
.lineno
;
1218 h
->ldscript_def
= 1;
1219 h
->rel_from_abs
= expld
.rel_from_abs
;
1220 if (tree
->assign
.hidden
)
1221 bfd_link_hide_symbol (link_info
.output_bfd
,
1224 /* Copy the symbol type and set non_ir_ref_regular
1225 on the source if this is an expression only
1226 referencing a single symbol. (If the expression
1227 contains ternary conditions, ignoring symbols on
1229 if (expld
.assign_src
!= NULL
1230 && (expld
.assign_src
1231 != (struct bfd_link_hash_entry
*) -1))
1233 bfd_copy_link_hash_symbol_type (link_info
.output_bfd
,
1234 h
, expld
.assign_src
);
1235 expld
.assign_src
->non_ir_ref_regular
= true;
1240 if (expld
.phase
!= lang_fixed_phase_enum
)
1241 expld
.assign_name
= NULL
;
1251 memset (&expld
.result
, 0, sizeof (expld
.result
));
1257 exp_fold_tree (etree_type
*tree
, asection
*current_section
, bfd_vma
*dotp
)
1259 expld
.rel_from_abs
= false;
1262 expld
.section
= current_section
;
1263 exp_fold_tree_1 (tree
);
1267 exp_fold_tree_no_dot (etree_type
*tree
)
1269 expld
.rel_from_abs
= false;
1272 expld
.section
= bfd_abs_section_ptr
;
1273 exp_fold_tree_1 (tree
);
1277 exp_value_fold (etree_type
*tree
)
1279 exp_fold_tree_no_dot (tree
);
1280 if (expld
.result
.valid_p
)
1282 tree
->type
.node_code
= INT
;
1283 tree
->value
.value
= expld
.result
.value
;
1284 tree
->value
.str
= NULL
;
1285 tree
->type
.node_class
= etree_value
;
1289 #define MAX(a, b) ((a) > (b) ? (a) : (b))
1292 exp_binop (int code
, etree_type
*lhs
, etree_type
*rhs
)
1294 etree_type
*new_e
= stat_alloc (MAX (sizeof (new_e
->binary
),
1295 sizeof (new_e
->value
)));
1296 new_e
->type
.node_code
= code
;
1297 new_e
->type
.filename
= lhs
->type
.filename
;
1298 new_e
->type
.lineno
= lhs
->type
.lineno
;
1299 new_e
->binary
.lhs
= lhs
;
1300 new_e
->binary
.rhs
= rhs
;
1301 new_e
->type
.node_class
= etree_binary
;
1302 if (lhs
->type
.node_class
== etree_value
1303 && rhs
->type
.node_class
== etree_value
1305 && code
!= DATA_SEGMENT_ALIGN
1306 && code
!= DATA_SEGMENT_RELRO_END
)
1307 exp_value_fold (new_e
);
1312 exp_trinop (int code
, etree_type
*cond
, etree_type
*lhs
, etree_type
*rhs
)
1314 etree_type
*new_e
= stat_alloc (MAX (sizeof (new_e
->trinary
),
1315 sizeof (new_e
->value
)));
1316 new_e
->type
.node_code
= code
;
1317 new_e
->type
.filename
= cond
->type
.filename
;
1318 new_e
->type
.lineno
= cond
->type
.lineno
;
1319 new_e
->trinary
.lhs
= lhs
;
1320 new_e
->trinary
.cond
= cond
;
1321 new_e
->trinary
.rhs
= rhs
;
1322 new_e
->type
.node_class
= etree_trinary
;
1323 if (cond
->type
.node_class
== etree_value
1324 && lhs
->type
.node_class
== etree_value
1325 && rhs
->type
.node_class
== etree_value
)
1326 exp_value_fold (new_e
);
1331 exp_unop (int code
, etree_type
*child
)
1333 etree_type
*new_e
= stat_alloc (MAX (sizeof (new_e
->unary
),
1334 sizeof (new_e
->value
)));
1335 new_e
->unary
.type
.node_code
= code
;
1336 new_e
->unary
.type
.filename
= child
->type
.filename
;
1337 new_e
->unary
.type
.lineno
= child
->type
.lineno
;
1338 new_e
->unary
.child
= child
;
1339 new_e
->unary
.type
.node_class
= etree_unary
;
1340 if (child
->type
.node_class
== etree_value
1344 && code
!= DATA_SEGMENT_END
)
1345 exp_value_fold (new_e
);
1350 exp_nameop (int code
, const char *name
)
1352 etree_type
*new_e
= stat_alloc (sizeof (new_e
->name
));
1354 new_e
->name
.type
.node_code
= code
;
1355 new_e
->name
.type
.filename
= ldlex_filename ();
1356 new_e
->name
.type
.lineno
= lineno
;
1357 new_e
->name
.name
= name
;
1358 new_e
->name
.type
.node_class
= etree_name
;
1364 exp_assop (const char *dst
,
1366 enum node_tree_enum
class,
1371 n
= stat_alloc (sizeof (n
->assign
));
1372 n
->assign
.type
.node_code
= '=';
1373 n
->assign
.type
.filename
= src
->type
.filename
;
1374 n
->assign
.type
.lineno
= src
->type
.lineno
;
1375 n
->assign
.type
.node_class
= class;
1376 n
->assign
.src
= src
;
1377 n
->assign
.dst
= dst
;
1378 n
->assign
.hidden
= hidden
;
1382 /* Handle linker script assignments and HIDDEN. */
1385 exp_assign (const char *dst
, etree_type
*src
, bool hidden
)
1387 return exp_assop (dst
, src
, etree_assign
, hidden
);
1390 /* Handle --defsym command-line option. */
1393 exp_defsym (const char *dst
, etree_type
*src
)
1395 return exp_assop (dst
, src
, etree_assign
, false);
1398 /* Handle PROVIDE. */
1401 exp_provide (const char *dst
, etree_type
*src
, bool hidden
)
1403 return exp_assop (dst
, src
, etree_provide
, hidden
);
1406 /* Handle ASSERT. */
1409 exp_assert (etree_type
*exp
, const char *message
)
1413 n
= stat_alloc (sizeof (n
->assert_s
));
1414 n
->assert_s
.type
.node_code
= '!';
1415 n
->assert_s
.type
.filename
= exp
->type
.filename
;
1416 n
->assert_s
.type
.lineno
= exp
->type
.lineno
;
1417 n
->assert_s
.type
.node_class
= etree_assert
;
1418 n
->assert_s
.child
= exp
;
1419 n
->assert_s
.message
= message
;
1424 exp_print_tree (etree_type
*tree
)
1428 if (config
.map_file
== NULL
)
1429 config
.map_file
= stderr
;
1433 minfo ("NULL TREE\n");
1437 switch (tree
->type
.node_class
)
1440 minfo ("0x%v", tree
->value
.value
);
1443 if (tree
->rel
.section
->owner
!= NULL
)
1444 minfo ("%pB:", tree
->rel
.section
->owner
);
1445 minfo ("%s+0x%v", tree
->rel
.section
->name
, tree
->rel
.value
);
1448 fputs (tree
->assign
.dst
, config
.map_file
);
1449 exp_print_token (tree
->type
.node_code
, true);
1450 exp_print_tree (tree
->assign
.src
);
1453 case etree_provided
:
1454 fprintf (config
.map_file
, "PROVIDE (%s = ", tree
->assign
.dst
);
1455 exp_print_tree (tree
->assign
.src
);
1456 fputc (')', config
.map_file
);
1459 function_like
= false;
1460 switch (tree
->type
.node_code
)
1465 case DATA_SEGMENT_ALIGN
:
1466 case DATA_SEGMENT_RELRO_END
:
1467 function_like
= true;
1470 /* Special handling because arguments are in reverse order and
1471 the segment name is quoted. */
1472 exp_print_token (tree
->type
.node_code
, false);
1473 fputs (" (\"", config
.map_file
);
1474 exp_print_tree (tree
->binary
.rhs
);
1475 fputs ("\", ", config
.map_file
);
1476 exp_print_tree (tree
->binary
.lhs
);
1477 fputc (')', config
.map_file
);
1482 exp_print_token (tree
->type
.node_code
, false);
1483 fputc (' ', config
.map_file
);
1485 fputc ('(', config
.map_file
);
1486 exp_print_tree (tree
->binary
.lhs
);
1488 fprintf (config
.map_file
, ", ");
1490 exp_print_token (tree
->type
.node_code
, true);
1491 exp_print_tree (tree
->binary
.rhs
);
1492 fputc (')', config
.map_file
);
1495 exp_print_tree (tree
->trinary
.cond
);
1496 fputc ('?', config
.map_file
);
1497 exp_print_tree (tree
->trinary
.lhs
);
1498 fputc (':', config
.map_file
);
1499 exp_print_tree (tree
->trinary
.rhs
);
1502 exp_print_token (tree
->unary
.type
.node_code
, false);
1503 if (tree
->unary
.child
)
1505 fprintf (config
.map_file
, " (");
1506 exp_print_tree (tree
->unary
.child
);
1507 fputc (')', config
.map_file
);
1512 fprintf (config
.map_file
, "ASSERT (");
1513 exp_print_tree (tree
->assert_s
.child
);
1514 fprintf (config
.map_file
, ", %s)", tree
->assert_s
.message
);
1518 if (tree
->type
.node_code
== NAME
)
1519 fputs (tree
->name
.name
, config
.map_file
);
1522 exp_print_token (tree
->type
.node_code
, false);
1523 if (tree
->name
.name
)
1524 fprintf (config
.map_file
, " (%s)", tree
->name
.name
);
1534 exp_get_vma (etree_type
*tree
, bfd_vma def
, char *name
)
1538 exp_fold_tree_no_dot (tree
);
1539 if (expld
.result
.valid_p
)
1540 return expld
.result
.value
;
1541 else if (name
!= NULL
&& expld
.phase
!= lang_mark_phase_enum
)
1542 einfo (_("%F%P:%pS: nonconstant expression for %s\n"),
1548 /* Return the smallest non-negative integer such that two raised to
1549 that power is at least as large as the vma evaluated at TREE, if
1550 TREE is a non-NULL expression that can be resolved. If TREE is
1551 NULL or cannot be resolved, return -1. */
1554 exp_get_power (etree_type
*tree
, char *name
)
1556 bfd_vma x
= exp_get_vma (tree
, -1, name
);
1560 if (x
== (bfd_vma
) -1)
1563 for (n
= 0, p2
= 1; p2
< x
; ++n
, p2
<<= 1)
1571 exp_get_fill (etree_type
*tree
, fill_type
*def
, char *name
)
1580 exp_fold_tree_no_dot (tree
);
1581 if (!expld
.result
.valid_p
)
1583 if (name
!= NULL
&& expld
.phase
!= lang_mark_phase_enum
)
1584 einfo (_("%F%P:%pS: nonconstant expression for %s\n"),
1589 if (expld
.result
.str
!= NULL
&& (len
= strlen (expld
.result
.str
)) != 0)
1593 fill
= (fill_type
*) xmalloc ((len
+ 1) / 2 + sizeof (*fill
) - 1);
1594 fill
->size
= (len
+ 1) / 2;
1596 s
= (unsigned char *) expld
.result
.str
;
1604 digit
= (digit
- 'A' + '0' + 10) & 0xf;
1618 fill
= (fill_type
*) xmalloc (4 + sizeof (*fill
) - 1);
1619 val
= expld
.result
.value
;
1620 fill
->data
[0] = (val
>> 24) & 0xff;
1621 fill
->data
[1] = (val
>> 16) & 0xff;
1622 fill
->data
[2] = (val
>> 8) & 0xff;
1623 fill
->data
[3] = (val
>> 0) & 0xff;
1630 exp_get_abs_int (etree_type
*tree
, int def
, char *name
)
1634 exp_fold_tree_no_dot (tree
);
1636 if (expld
.result
.valid_p
)
1638 if (expld
.result
.section
!= NULL
)
1639 expld
.result
.value
+= expld
.result
.section
->vma
;
1640 return expld
.result
.value
;
1642 else if (name
!= NULL
&& expld
.phase
!= lang_mark_phase_enum
)
1644 einfo (_("%F%P:%pS: nonconstant expression for %s\n"),
1652 align_n (bfd_vma value
, bfd_vma align
)
1657 value
= (value
+ align
- 1) / align
;
1658 return value
* align
;
1664 /* The value "13" is ad-hoc, somewhat related to the expected number of
1665 assignments in a linker script. */
1666 if (!bfd_hash_table_init_n (&definedness_table
,
1667 definedness_newfunc
,
1668 sizeof (struct definedness_hash_entry
),
1670 einfo (_("%F%P: can not create hash table: %E\n"));
1673 /* Convert absolute symbols defined by a script from "dot" (also
1674 SEGMENT_START or ORIGIN) outside of an output section statement,
1675 to section relative. */
1678 set_sym_sections (struct bfd_hash_entry
*bh
, void *inf ATTRIBUTE_UNUSED
)
1680 struct definedness_hash_entry
*def
= (struct definedness_hash_entry
*) bh
;
1681 if (def
->final_sec
!= bfd_abs_section_ptr
)
1683 struct bfd_link_hash_entry
*h
;
1684 h
= bfd_link_hash_lookup (link_info
.hash
, bh
->string
,
1685 false, false, true);
1687 && h
->type
== bfd_link_hash_defined
1688 && h
->u
.def
.section
== bfd_abs_section_ptr
)
1690 h
->u
.def
.value
-= def
->final_sec
->vma
;
1691 h
->u
.def
.section
= def
->final_sec
;
1698 ldexp_finalize_syms (void)
1700 bfd_hash_traverse (&definedness_table
, set_sym_sections
, NULL
);
1703 /* Determine whether a symbol is going to remain absolute even after
1704 ldexp_finalize_syms() has run. */
1707 ldexp_is_final_sym_absolute (const struct bfd_link_hash_entry
*h
)
1709 if (h
->type
== bfd_link_hash_defined
1710 && h
->u
.def
.section
== bfd_abs_section_ptr
)
1712 const struct definedness_hash_entry
*def
;
1714 if (!h
->ldscript_def
)
1717 def
= symbol_defined (h
->root
.string
);
1719 return def
->final_sec
== bfd_abs_section_ptr
;
1728 bfd_hash_table_free (&definedness_table
);