1 /* This module handles expression trees.
2 Copyright (C) 1991-2020 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
,
734 if (expld
.phase
!= lang_first_phase_enum
)
735 einfo (_("%F%P: bfd_link_hash_lookup failed: %E\n"));
737 else if (h
->type
== bfd_link_hash_defined
738 || h
->type
== bfd_link_hash_defweak
)
740 asection
*output_section
;
742 output_section
= h
->u
.def
.section
->output_section
;
743 if (output_section
== NULL
)
745 if (expld
.phase
<= lang_mark_phase_enum
)
746 new_rel (h
->u
.def
.value
, h
->u
.def
.section
);
748 einfo (_("%X%P:%pS: unresolvable symbol `%s'"
749 " referenced in expression\n"),
750 tree
, tree
->name
.name
);
752 else if (output_section
== bfd_abs_section_ptr
753 && (expld
.section
!= bfd_abs_section_ptr
754 || config
.sane_expr
))
755 new_number (h
->u
.def
.value
+ h
->u
.def
.section
->output_offset
);
757 new_rel (h
->u
.def
.value
+ h
->u
.def
.section
->output_offset
,
760 else if (expld
.phase
== lang_final_phase_enum
761 || (expld
.phase
!= lang_mark_phase_enum
762 && expld
.assigning_to_dot
))
763 einfo (_("%F%P:%pS: undefined symbol `%s'"
764 " referenced in expression\n"),
765 tree
, tree
->name
.name
);
766 else if (h
->type
== bfd_link_hash_new
)
768 h
->type
= bfd_link_hash_undefined
;
769 h
->u
.undef
.abfd
= NULL
;
770 if (h
->u
.undef
.next
== NULL
&& h
!= link_info
.hash
->undefs_tail
)
771 bfd_link_add_undef (link_info
.hash
, h
);
773 if (expld
.assign_src
== NULL
)
774 expld
.assign_src
= h
;
776 expld
.assign_src
= (struct bfd_link_hash_entry
*) - 1;
778 /* Self-assignment is only allowed for absolute symbols
779 defined in a linker script. */
780 if (expld
.assign_name
!= NULL
781 && strcmp (expld
.assign_name
, tree
->name
.name
) == 0
783 && (h
->type
== bfd_link_hash_defined
784 || h
->type
== bfd_link_hash_defweak
)
785 && h
->u
.def
.section
== bfd_abs_section_ptr
786 && (def
= symbol_defined (tree
->name
.name
)) != NULL
787 && def
->iteration
== (lang_statement_iteration
& 255)))
788 expld
.assign_name
= NULL
;
793 if (expld
.phase
!= lang_first_phase_enum
)
795 lang_output_section_statement_type
*os
;
797 os
= lang_output_section_find (tree
->name
.name
);
800 if (expld
.phase
== lang_final_phase_enum
)
801 einfo (_("%F%P:%pS: undefined section `%s'"
802 " referenced in expression\n"),
803 tree
, tree
->name
.name
);
805 else if (os
->processed_vma
)
806 new_rel (0, os
->bfd_section
);
811 if (expld
.phase
!= lang_first_phase_enum
)
813 lang_output_section_statement_type
*os
;
815 os
= lang_output_section_find (tree
->name
.name
);
818 if (expld
.phase
== lang_final_phase_enum
)
819 einfo (_("%F%P:%pS: undefined section `%s'"
820 " referenced in expression\n"),
821 tree
, tree
->name
.name
);
823 else if (os
->processed_lma
)
825 if (os
->load_base
== NULL
)
826 new_abs (os
->bfd_section
->lma
);
829 exp_fold_tree_1 (os
->load_base
);
830 if (expld
.result
.valid_p
)
839 if (expld
.phase
!= lang_first_phase_enum
)
841 lang_output_section_statement_type
*os
;
843 os
= lang_output_section_find (tree
->name
.name
);
846 if (expld
.phase
== lang_final_phase_enum
)
847 einfo (_("%F%P:%pS: undefined section `%s'"
848 " referenced in expression\n"),
849 tree
, tree
->name
.name
);
852 else if (os
->bfd_section
!= NULL
)
856 if (tree
->type
.node_code
== SIZEOF
)
857 val
= (os
->bfd_section
->size
858 / bfd_octets_per_byte (link_info
.output_bfd
,
861 val
= (bfd_vma
)1 << os
->bfd_section
->alignment_power
;
872 lang_memory_region_type
*mem
;
874 mem
= lang_memory_region_lookup (tree
->name
.name
, FALSE
);
876 new_number (mem
->length
);
878 einfo (_("%F%P:%pS: undefined MEMORY region `%s'"
879 " referenced in expression\n"),
880 tree
, tree
->name
.name
);
886 lang_memory_region_type
*mem
;
888 mem
= lang_memory_region_lookup (tree
->name
.name
, FALSE
);
890 new_rel_from_abs (mem
->origin
);
892 einfo (_("%F%P:%pS: undefined MEMORY region `%s'"
893 " referenced in expression\n"),
894 tree
, tree
->name
.name
);
899 if (strcmp (tree
->name
.name
, "MAXPAGESIZE") == 0)
900 new_number (config
.maxpagesize
);
901 else if (strcmp (tree
->name
.name
, "COMMONPAGESIZE") == 0)
902 new_number (config
.commonpagesize
);
904 einfo (_("%F%P:%pS: unknown constant `%s' referenced in expression\n"),
905 tree
, tree
->name
.name
);
914 /* Return true if TREE is '.'. */
917 is_dot (const etree_type
*tree
)
919 return (tree
->type
.node_class
== etree_name
920 && tree
->type
.node_code
== NAME
921 && tree
->name
.name
[0] == '.'
922 && tree
->name
.name
[1] == 0);
925 /* Return true if TREE is a constant equal to VAL. */
928 is_value (const etree_type
*tree
, bfd_vma val
)
930 return (tree
->type
.node_class
== etree_value
931 && tree
->value
.value
== val
);
934 /* Return true if TREE is an absolute symbol equal to VAL defined in
938 is_sym_value (const etree_type
*tree
, bfd_vma val
)
940 struct bfd_link_hash_entry
*h
;
941 struct definedness_hash_entry
*def
;
943 return (tree
->type
.node_class
== etree_name
944 && tree
->type
.node_code
== NAME
945 && (def
= symbol_defined (tree
->name
.name
)) != NULL
946 && def
->iteration
== (lang_statement_iteration
& 255)
947 && (h
= bfd_wrapped_link_hash_lookup (link_info
.output_bfd
,
950 FALSE
, FALSE
, TRUE
)) != NULL
952 && h
->type
== bfd_link_hash_defined
953 && h
->u
.def
.section
== bfd_abs_section_ptr
954 && h
->u
.def
.value
== val
);
957 /* Return true if TREE is ". != 0". */
960 is_dot_ne_0 (const etree_type
*tree
)
962 return (tree
->type
.node_class
== etree_binary
963 && tree
->type
.node_code
== NE
964 && is_dot (tree
->binary
.lhs
)
965 && is_value (tree
->binary
.rhs
, 0));
968 /* Return true if TREE is ". = . + 0" or ". = . + sym" where sym is an
969 absolute constant with value 0 defined in a linker script. */
972 is_dot_plus_0 (const etree_type
*tree
)
974 return (tree
->type
.node_class
== etree_binary
975 && tree
->type
.node_code
== '+'
976 && is_dot (tree
->binary
.lhs
)
977 && (is_value (tree
->binary
.rhs
, 0)
978 || is_sym_value (tree
->binary
.rhs
, 0)));
981 /* Return true if TREE is "ALIGN (. != 0 ? some_expression : 1)". */
984 is_align_conditional (const etree_type
*tree
)
986 if (tree
->type
.node_class
== etree_unary
987 && tree
->type
.node_code
== ALIGN_K
)
989 tree
= tree
->unary
.child
;
990 return (tree
->type
.node_class
== etree_trinary
991 && is_dot_ne_0 (tree
->trinary
.cond
)
992 && is_value (tree
->trinary
.rhs
, 1));
998 exp_fold_tree_1 (etree_type
*tree
)
1002 memset (&expld
.result
, 0, sizeof (expld
.result
));
1006 switch (tree
->type
.node_class
)
1009 if (expld
.section
== bfd_abs_section_ptr
1010 && !config
.sane_expr
)
1011 new_abs (tree
->value
.value
);
1013 new_number (tree
->value
.value
);
1014 expld
.result
.str
= tree
->value
.str
;
1018 if (expld
.phase
!= lang_first_phase_enum
)
1020 asection
*output_section
= tree
->rel
.section
->output_section
;
1021 new_rel (tree
->rel
.value
+ tree
->rel
.section
->output_offset
,
1025 memset (&expld
.result
, 0, sizeof (expld
.result
));
1029 exp_fold_tree_1 (tree
->assert_s
.child
);
1030 if (expld
.phase
== lang_final_phase_enum
&& !expld
.result
.value
)
1031 einfo ("%X%P: %s\n", tree
->assert_s
.message
);
1043 fold_trinary (tree
);
1048 case etree_provided
:
1049 if (tree
->assign
.dst
[0] == '.' && tree
->assign
.dst
[1] == 0)
1051 if (tree
->type
.node_class
!= etree_assign
)
1052 einfo (_("%F%P:%pS can not PROVIDE assignment to"
1053 " location counter\n"), tree
);
1054 if (expld
.phase
!= lang_first_phase_enum
)
1056 /* Notify the folder that this is an assignment to dot. */
1057 expld
.assigning_to_dot
= TRUE
;
1058 exp_fold_tree_1 (tree
->assign
.src
);
1059 expld
.assigning_to_dot
= FALSE
;
1061 /* If we are assigning to dot inside an output section
1062 arrange to keep the section, except for certain
1063 expressions that evaluate to zero. We ignore . = 0,
1064 . = . + 0, and . = ALIGN (. != 0 ? expr : 1).
1065 We can't ignore all expressions that evaluate to zero
1066 because an otherwise empty section might have padding
1067 added by an alignment expression that changes with
1068 relaxation. Such a section might have zero size
1069 before relaxation and so be stripped incorrectly. */
1070 if (expld
.phase
== lang_mark_phase_enum
1071 && expld
.section
!= bfd_abs_section_ptr
1072 && expld
.section
!= bfd_und_section_ptr
1073 && !(expld
.result
.valid_p
1074 && expld
.result
.value
== 0
1075 && (is_value (tree
->assign
.src
, 0)
1076 || is_sym_value (tree
->assign
.src
, 0)
1077 || is_dot_plus_0 (tree
->assign
.src
)
1078 || is_align_conditional (tree
->assign
.src
))))
1079 expld
.section
->flags
|= SEC_KEEP
;
1081 if (!expld
.result
.valid_p
1082 || expld
.section
== bfd_und_section_ptr
)
1084 if (expld
.phase
!= lang_mark_phase_enum
)
1085 einfo (_("%F%P:%pS invalid assignment to"
1086 " location counter\n"), tree
);
1088 else if (expld
.dotp
== NULL
)
1089 einfo (_("%F%P:%pS assignment to location counter"
1090 " invalid outside of SECTIONS\n"), tree
);
1092 /* After allocation, assignment to dot should not be
1093 done inside an output section since allocation adds a
1094 padding statement that effectively duplicates the
1096 else if (expld
.phase
<= lang_allocating_phase_enum
1097 || expld
.section
== bfd_abs_section_ptr
)
1101 nextdot
= expld
.result
.value
;
1102 if (expld
.result
.section
!= NULL
)
1103 nextdot
+= expld
.result
.section
->vma
;
1105 nextdot
+= expld
.section
->vma
;
1106 if (nextdot
< expld
.dot
1107 && expld
.section
!= bfd_abs_section_ptr
)
1108 einfo (_("%F%P:%pS cannot move location counter backwards"
1109 " (from %V to %V)\n"),
1110 tree
, expld
.dot
, nextdot
);
1113 expld
.dot
= nextdot
;
1114 *expld
.dotp
= nextdot
;
1119 memset (&expld
.result
, 0, sizeof (expld
.result
));
1123 struct bfd_link_hash_entry
*h
= NULL
;
1125 if (tree
->type
.node_class
== etree_provide
)
1127 h
= bfd_link_hash_lookup (link_info
.hash
, tree
->assign
.dst
,
1128 FALSE
, FALSE
, TRUE
);
1130 || !(h
->type
== bfd_link_hash_new
1131 || h
->type
== bfd_link_hash_undefined
1132 || h
->type
== bfd_link_hash_undefweak
1135 /* Do nothing. The symbol was never referenced, or
1136 was defined in some object file. Note that
1137 undefweak symbols are defined by PROVIDE. This
1138 is to support glibc use of __rela_iplt_start and
1139 similar weak references. */
1144 expld
.assign_name
= tree
->assign
.dst
;
1145 expld
.assign_src
= NULL
;
1146 exp_fold_tree_1 (tree
->assign
.src
);
1147 /* expld.assign_name remaining equal to tree->assign.dst
1148 below indicates the evaluation of tree->assign.src did
1149 not use the value of tree->assign.dst. We don't allow
1150 self assignment until the final phase for two reasons:
1151 1) Expressions are evaluated multiple times. With
1152 relaxation, the number of times may vary.
1153 2) Section relative symbol values cannot be correctly
1154 converted to absolute values, as is required by many
1155 expressions, until final section sizing is complete. */
1156 if (expld
.phase
== lang_final_phase_enum
1157 || expld
.phase
== lang_fixed_phase_enum
1158 || expld
.assign_name
!= NULL
)
1160 if (tree
->type
.node_class
== etree_provide
)
1161 tree
->type
.node_class
= etree_provided
;
1165 h
= bfd_link_hash_lookup (link_info
.hash
, tree
->assign
.dst
,
1168 einfo (_("%F%P:%s: hash creation failed\n"),
1172 /* If the expression is not valid then fake a zero value. In
1173 the final phase any errors will already have been raised,
1174 in earlier phases we want to create this definition so
1175 that it can be seen by other expressions. */
1176 if (!expld
.result
.valid_p
1177 && h
->type
== bfd_link_hash_new
)
1179 expld
.result
.value
= 0;
1180 expld
.result
.section
= NULL
;
1181 expld
.result
.valid_p
= TRUE
;
1184 if (expld
.result
.valid_p
)
1186 if (expld
.result
.section
== NULL
)
1187 expld
.result
.section
= expld
.section
;
1188 if (!update_definedness (tree
->assign
.dst
, h
) && 0)
1190 /* Symbol was already defined. For now this error
1191 is disabled because it causes failures in the ld
1192 testsuite: ld-elf/var1, ld-scripts/defined5, and
1193 ld-scripts/pr14962. Some of these no doubt
1194 reflect scripts used in the wild. */
1195 (*link_info
.callbacks
->multiple_definition
)
1196 (&link_info
, h
, link_info
.output_bfd
,
1197 expld
.result
.section
, expld
.result
.value
);
1199 if (expld
.phase
== lang_fixed_phase_enum
)
1201 if (h
->type
== bfd_link_hash_defined
)
1203 expld
.result
.value
= h
->u
.def
.value
;
1204 expld
.result
.section
= h
->u
.def
.section
;
1209 h
->type
= bfd_link_hash_defined
;
1210 h
->u
.def
.value
= expld
.result
.value
;
1211 h
->u
.def
.section
= expld
.result
.section
;
1212 h
->linker_def
= ! tree
->assign
.type
.lineno
;
1213 h
->ldscript_def
= 1;
1214 h
->rel_from_abs
= expld
.rel_from_abs
;
1215 if (tree
->assign
.hidden
)
1216 bfd_link_hide_symbol (link_info
.output_bfd
,
1219 /* Copy the symbol type if this is an expression only
1220 referencing a single symbol. (If the expression
1221 contains ternary conditions, ignoring symbols on
1223 if (expld
.assign_src
!= NULL
1224 && (expld
.assign_src
1225 != (struct bfd_link_hash_entry
*) -1))
1226 bfd_copy_link_hash_symbol_type (link_info
.output_bfd
,
1227 h
, expld
.assign_src
);
1231 if (expld
.phase
!= lang_fixed_phase_enum
)
1232 expld
.assign_name
= NULL
;
1242 memset (&expld
.result
, 0, sizeof (expld
.result
));
1248 exp_fold_tree (etree_type
*tree
, asection
*current_section
, bfd_vma
*dotp
)
1250 expld
.rel_from_abs
= FALSE
;
1253 expld
.section
= current_section
;
1254 exp_fold_tree_1 (tree
);
1258 exp_fold_tree_no_dot (etree_type
*tree
)
1260 expld
.rel_from_abs
= FALSE
;
1263 expld
.section
= bfd_abs_section_ptr
;
1264 exp_fold_tree_1 (tree
);
1268 exp_value_fold (etree_type
*tree
)
1270 exp_fold_tree_no_dot (tree
);
1271 if (expld
.result
.valid_p
)
1273 tree
->type
.node_code
= INT
;
1274 tree
->value
.value
= expld
.result
.value
;
1275 tree
->value
.str
= NULL
;
1276 tree
->type
.node_class
= etree_value
;
1280 #define MAX(a, b) ((a) > (b) ? (a) : (b))
1283 exp_binop (int code
, etree_type
*lhs
, etree_type
*rhs
)
1285 etree_type
*new_e
= stat_alloc (MAX (sizeof (new_e
->binary
),
1286 sizeof (new_e
->value
)));
1287 new_e
->type
.node_code
= code
;
1288 new_e
->type
.filename
= lhs
->type
.filename
;
1289 new_e
->type
.lineno
= lhs
->type
.lineno
;
1290 new_e
->binary
.lhs
= lhs
;
1291 new_e
->binary
.rhs
= rhs
;
1292 new_e
->type
.node_class
= etree_binary
;
1293 if (lhs
->type
.node_class
== etree_value
1294 && rhs
->type
.node_class
== etree_value
1296 && code
!= DATA_SEGMENT_ALIGN
1297 && code
!= DATA_SEGMENT_RELRO_END
)
1298 exp_value_fold (new_e
);
1303 exp_trinop (int code
, etree_type
*cond
, etree_type
*lhs
, etree_type
*rhs
)
1305 etree_type
*new_e
= stat_alloc (MAX (sizeof (new_e
->trinary
),
1306 sizeof (new_e
->value
)));
1307 new_e
->type
.node_code
= code
;
1308 new_e
->type
.filename
= cond
->type
.filename
;
1309 new_e
->type
.lineno
= cond
->type
.lineno
;
1310 new_e
->trinary
.lhs
= lhs
;
1311 new_e
->trinary
.cond
= cond
;
1312 new_e
->trinary
.rhs
= rhs
;
1313 new_e
->type
.node_class
= etree_trinary
;
1314 if (cond
->type
.node_class
== etree_value
1315 && lhs
->type
.node_class
== etree_value
1316 && rhs
->type
.node_class
== etree_value
)
1317 exp_value_fold (new_e
);
1322 exp_unop (int code
, etree_type
*child
)
1324 etree_type
*new_e
= stat_alloc (MAX (sizeof (new_e
->unary
),
1325 sizeof (new_e
->value
)));
1326 new_e
->unary
.type
.node_code
= code
;
1327 new_e
->unary
.type
.filename
= child
->type
.filename
;
1328 new_e
->unary
.type
.lineno
= child
->type
.lineno
;
1329 new_e
->unary
.child
= child
;
1330 new_e
->unary
.type
.node_class
= etree_unary
;
1331 if (child
->type
.node_class
== etree_value
1335 && code
!= DATA_SEGMENT_END
)
1336 exp_value_fold (new_e
);
1341 exp_nameop (int code
, const char *name
)
1343 etree_type
*new_e
= stat_alloc (sizeof (new_e
->name
));
1345 new_e
->name
.type
.node_code
= code
;
1346 new_e
->name
.type
.filename
= ldlex_filename ();
1347 new_e
->name
.type
.lineno
= lineno
;
1348 new_e
->name
.name
= name
;
1349 new_e
->name
.type
.node_class
= etree_name
;
1355 exp_assop (const char *dst
,
1357 enum node_tree_enum
class,
1362 n
= stat_alloc (sizeof (n
->assign
));
1363 n
->assign
.type
.node_code
= '=';
1364 n
->assign
.type
.filename
= src
->type
.filename
;
1365 n
->assign
.type
.lineno
= src
->type
.lineno
;
1366 n
->assign
.type
.node_class
= class;
1367 n
->assign
.src
= src
;
1368 n
->assign
.dst
= dst
;
1369 n
->assign
.hidden
= hidden
;
1373 /* Handle linker script assignments and HIDDEN. */
1376 exp_assign (const char *dst
, etree_type
*src
, bfd_boolean hidden
)
1378 return exp_assop (dst
, src
, etree_assign
, hidden
);
1381 /* Handle --defsym command-line option. */
1384 exp_defsym (const char *dst
, etree_type
*src
)
1386 return exp_assop (dst
, src
, etree_assign
, FALSE
);
1389 /* Handle PROVIDE. */
1392 exp_provide (const char *dst
, etree_type
*src
, bfd_boolean hidden
)
1394 return exp_assop (dst
, src
, etree_provide
, hidden
);
1397 /* Handle ASSERT. */
1400 exp_assert (etree_type
*exp
, const char *message
)
1404 n
= stat_alloc (sizeof (n
->assert_s
));
1405 n
->assert_s
.type
.node_code
= '!';
1406 n
->assert_s
.type
.filename
= exp
->type
.filename
;
1407 n
->assert_s
.type
.lineno
= exp
->type
.lineno
;
1408 n
->assert_s
.type
.node_class
= etree_assert
;
1409 n
->assert_s
.child
= exp
;
1410 n
->assert_s
.message
= message
;
1415 exp_print_tree (etree_type
*tree
)
1417 bfd_boolean function_like
;
1419 if (config
.map_file
== NULL
)
1420 config
.map_file
= stderr
;
1424 minfo ("NULL TREE\n");
1428 switch (tree
->type
.node_class
)
1431 minfo ("0x%v", tree
->value
.value
);
1434 if (tree
->rel
.section
->owner
!= NULL
)
1435 minfo ("%pB:", tree
->rel
.section
->owner
);
1436 minfo ("%s+0x%v", tree
->rel
.section
->name
, tree
->rel
.value
);
1439 fputs (tree
->assign
.dst
, config
.map_file
);
1440 exp_print_token (tree
->type
.node_code
, TRUE
);
1441 exp_print_tree (tree
->assign
.src
);
1444 case etree_provided
:
1445 fprintf (config
.map_file
, "PROVIDE (%s = ", tree
->assign
.dst
);
1446 exp_print_tree (tree
->assign
.src
);
1447 fputc (')', config
.map_file
);
1450 function_like
= FALSE
;
1451 switch (tree
->type
.node_code
)
1456 case DATA_SEGMENT_ALIGN
:
1457 case DATA_SEGMENT_RELRO_END
:
1458 function_like
= TRUE
;
1461 /* Special handling because arguments are in reverse order and
1462 the segment name is quoted. */
1463 exp_print_token (tree
->type
.node_code
, FALSE
);
1464 fputs (" (\"", config
.map_file
);
1465 exp_print_tree (tree
->binary
.rhs
);
1466 fputs ("\", ", config
.map_file
);
1467 exp_print_tree (tree
->binary
.lhs
);
1468 fputc (')', config
.map_file
);
1473 exp_print_token (tree
->type
.node_code
, FALSE
);
1474 fputc (' ', config
.map_file
);
1476 fputc ('(', config
.map_file
);
1477 exp_print_tree (tree
->binary
.lhs
);
1479 fprintf (config
.map_file
, ", ");
1481 exp_print_token (tree
->type
.node_code
, TRUE
);
1482 exp_print_tree (tree
->binary
.rhs
);
1483 fputc (')', config
.map_file
);
1486 exp_print_tree (tree
->trinary
.cond
);
1487 fputc ('?', config
.map_file
);
1488 exp_print_tree (tree
->trinary
.lhs
);
1489 fputc (':', config
.map_file
);
1490 exp_print_tree (tree
->trinary
.rhs
);
1493 exp_print_token (tree
->unary
.type
.node_code
, FALSE
);
1494 if (tree
->unary
.child
)
1496 fprintf (config
.map_file
, " (");
1497 exp_print_tree (tree
->unary
.child
);
1498 fputc (')', config
.map_file
);
1503 fprintf (config
.map_file
, "ASSERT (");
1504 exp_print_tree (tree
->assert_s
.child
);
1505 fprintf (config
.map_file
, ", %s)", tree
->assert_s
.message
);
1509 if (tree
->type
.node_code
== NAME
)
1510 fputs (tree
->name
.name
, config
.map_file
);
1513 exp_print_token (tree
->type
.node_code
, FALSE
);
1514 if (tree
->name
.name
)
1515 fprintf (config
.map_file
, " (%s)", tree
->name
.name
);
1525 exp_get_vma (etree_type
*tree
, bfd_vma def
, char *name
)
1529 exp_fold_tree_no_dot (tree
);
1530 if (expld
.result
.valid_p
)
1531 return expld
.result
.value
;
1532 else if (name
!= NULL
&& expld
.phase
!= lang_mark_phase_enum
)
1533 einfo (_("%F%P:%pS: nonconstant expression for %s\n"),
1539 /* Return the smallest non-negative integer such that two raised to
1540 that power is at least as large as the vma evaluated at TREE, if
1541 TREE is a non-NULL expression that can be resolved. If TREE is
1542 NULL or cannot be resolved, return -1. */
1545 exp_get_power (etree_type
*tree
, char *name
)
1547 bfd_vma x
= exp_get_vma (tree
, -1, name
);
1551 if (x
== (bfd_vma
) -1)
1554 for (n
= 0, p2
= 1; p2
< x
; ++n
, p2
<<= 1)
1562 exp_get_fill (etree_type
*tree
, fill_type
*def
, char *name
)
1571 exp_fold_tree_no_dot (tree
);
1572 if (!expld
.result
.valid_p
)
1574 if (name
!= NULL
&& expld
.phase
!= lang_mark_phase_enum
)
1575 einfo (_("%F%P:%pS: nonconstant expression for %s\n"),
1580 if (expld
.result
.str
!= NULL
&& (len
= strlen (expld
.result
.str
)) != 0)
1584 fill
= (fill_type
*) xmalloc ((len
+ 1) / 2 + sizeof (*fill
) - 1);
1585 fill
->size
= (len
+ 1) / 2;
1587 s
= (unsigned char *) expld
.result
.str
;
1595 digit
= (digit
- 'A' + '0' + 10) & 0xf;
1609 fill
= (fill_type
*) xmalloc (4 + sizeof (*fill
) - 1);
1610 val
= expld
.result
.value
;
1611 fill
->data
[0] = (val
>> 24) & 0xff;
1612 fill
->data
[1] = (val
>> 16) & 0xff;
1613 fill
->data
[2] = (val
>> 8) & 0xff;
1614 fill
->data
[3] = (val
>> 0) & 0xff;
1621 exp_get_abs_int (etree_type
*tree
, int def
, char *name
)
1625 exp_fold_tree_no_dot (tree
);
1627 if (expld
.result
.valid_p
)
1629 if (expld
.result
.section
!= NULL
)
1630 expld
.result
.value
+= expld
.result
.section
->vma
;
1631 return expld
.result
.value
;
1633 else if (name
!= NULL
&& expld
.phase
!= lang_mark_phase_enum
)
1635 einfo (_("%F%P:%pS: nonconstant expression for %s\n"),
1643 align_n (bfd_vma value
, bfd_vma align
)
1648 value
= (value
+ align
- 1) / align
;
1649 return value
* align
;
1655 /* The value "13" is ad-hoc, somewhat related to the expected number of
1656 assignments in a linker script. */
1657 if (!bfd_hash_table_init_n (&definedness_table
,
1658 definedness_newfunc
,
1659 sizeof (struct definedness_hash_entry
),
1661 einfo (_("%F%P: can not create hash table: %E\n"));
1664 /* Convert absolute symbols defined by a script from "dot" (also
1665 SEGMENT_START or ORIGIN) outside of an output section statement,
1666 to section relative. */
1669 set_sym_sections (struct bfd_hash_entry
*bh
, void *inf ATTRIBUTE_UNUSED
)
1671 struct definedness_hash_entry
*def
= (struct definedness_hash_entry
*) bh
;
1672 if (def
->final_sec
!= bfd_abs_section_ptr
)
1674 struct bfd_link_hash_entry
*h
;
1675 h
= bfd_link_hash_lookup (link_info
.hash
, bh
->string
,
1676 FALSE
, FALSE
, TRUE
);
1678 && h
->type
== bfd_link_hash_defined
1679 && h
->u
.def
.section
== bfd_abs_section_ptr
)
1681 h
->u
.def
.value
-= def
->final_sec
->vma
;
1682 h
->u
.def
.section
= def
->final_sec
;
1689 ldexp_finalize_syms (void)
1691 bfd_hash_traverse (&definedness_table
, set_sym_sections
, NULL
);
1697 bfd_hash_table_free (&definedness_table
);