1 /* This module handles expression trees.
2 Copyright (C) 1991-2017 Free Software Foundation, Inc.
3 Written by Steve Chamberlain of Cygnus Support <sac@cygnus.com>.
5 This file is part of the GNU Binutils.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20 MA 02110-1301, USA. */
23 /* This module is in charge of working out the contents of expressions.
25 It has to keep track of the relative/absness of a symbol etc. This
26 is done by keeping all values in a struct (an etree_value_type)
27 which contains a value, a section to which it is relative and a
41 #include "libiberty.h"
42 #include "safe-ctype.h"
44 static void exp_fold_tree_1 (etree_type
*);
45 static bfd_vma
align_n (bfd_vma
, bfd_vma
);
47 segment_type
*segments
;
49 struct ldexp_control expld
;
51 /* This structure records symbols for which we need to keep track of
52 definedness for use in the DEFINED () test. It is also used in
53 making absolute symbols section relative late in the link. */
55 struct definedness_hash_entry
57 struct bfd_hash_entry root
;
59 /* If this symbol was assigned from "dot" outside of an output
60 section statement, the section we'd like it relative to. */
63 /* Symbol was defined by an object file. */
64 unsigned int by_object
: 1;
66 /* Symbols was defined by a script. */
67 unsigned int by_script
: 1;
69 /* Low bit of iteration count. Symbols with matching iteration have
70 been defined in this pass over the script. */
71 unsigned int iteration
: 1;
74 static struct bfd_hash_table definedness_table
;
76 /* Print the string representation of the given token. Surround it
77 with spaces if INFIX_P is TRUE. */
80 exp_print_token (token_code_type code
, int infix_p
)
107 { LOG2CEIL
, "LOG2CEIL" },
108 { ALIGN_K
, "ALIGN" },
115 { SECTIONS
, "SECTIONS" },
116 { SIZEOF_HEADERS
, "SIZEOF_HEADERS" },
117 { MEMORY
, "MEMORY" },
118 { DEFINED
, "DEFINED" },
119 { TARGET_K
, "TARGET" },
120 { SEARCH_DIR
, "SEARCH_DIR" },
124 { ALIGNOF
, "ALIGNOF" },
125 { SIZEOF
, "SIZEOF" },
127 { LOADADDR
, "LOADADDR" },
128 { CONSTANT
, "CONSTANT" },
129 { ABSOLUTE
, "ABSOLUTE" },
132 { ASSERT_K
, "ASSERT" },
133 { REL
, "relocatable" },
134 { DATA_SEGMENT_ALIGN
, "DATA_SEGMENT_ALIGN" },
135 { DATA_SEGMENT_RELRO_END
, "DATA_SEGMENT_RELRO_END" },
136 { DATA_SEGMENT_END
, "DATA_SEGMENT_END" },
137 { ORIGIN
, "ORIGIN" },
138 { LENGTH
, "LENGTH" },
139 { SEGMENT_START
, "SEGMENT_START" }
143 for (idx
= 0; idx
< ARRAY_SIZE (table
); idx
++)
144 if (table
[idx
].code
== code
)
148 fputc (' ', config
.map_file
);
150 if (idx
< ARRAY_SIZE (table
))
151 fputs (table
[idx
].name
, config
.map_file
);
153 fputc (code
, config
.map_file
);
155 fprintf (config
.map_file
, "<code %d>", code
);
158 fputc (' ', config
.map_file
);
164 bfd_vma value
= expld
.result
.value
;
166 bfd_boolean round_up
= FALSE
;
171 /* If more than one bit is set in the value we will need to round up. */
172 if ((value
> 1) && (value
& 1))
179 expld
.result
.section
= NULL
;
180 expld
.result
.value
= result
;
186 if (expld
.result
.section
!= NULL
)
187 expld
.result
.value
+= expld
.result
.section
->vma
;
188 expld
.result
.section
= bfd_abs_section_ptr
;
189 expld
.rel_from_abs
= FALSE
;
193 new_abs (bfd_vma value
)
195 expld
.result
.valid_p
= TRUE
;
196 expld
.result
.section
= bfd_abs_section_ptr
;
197 expld
.result
.value
= value
;
198 expld
.result
.str
= NULL
;
202 exp_intop (bfd_vma value
)
204 etree_type
*new_e
= (etree_type
*) stat_alloc (sizeof (new_e
->value
));
205 new_e
->type
.node_code
= INT
;
206 new_e
->type
.filename
= ldlex_filename ();
207 new_e
->type
.lineno
= lineno
;
208 new_e
->value
.value
= value
;
209 new_e
->value
.str
= NULL
;
210 new_e
->type
.node_class
= etree_value
;
215 exp_bigintop (bfd_vma value
, char *str
)
217 etree_type
*new_e
= (etree_type
*) stat_alloc (sizeof (new_e
->value
));
218 new_e
->type
.node_code
= INT
;
219 new_e
->type
.filename
= ldlex_filename ();
220 new_e
->type
.lineno
= lineno
;
221 new_e
->value
.value
= value
;
222 new_e
->value
.str
= str
;
223 new_e
->type
.node_class
= etree_value
;
227 /* Build an expression representing an unnamed relocatable value. */
230 exp_relop (asection
*section
, bfd_vma value
)
232 etree_type
*new_e
= (etree_type
*) stat_alloc (sizeof (new_e
->rel
));
233 new_e
->type
.node_code
= REL
;
234 new_e
->type
.filename
= ldlex_filename ();
235 new_e
->type
.lineno
= lineno
;
236 new_e
->type
.node_class
= etree_rel
;
237 new_e
->rel
.section
= section
;
238 new_e
->rel
.value
= value
;
243 new_number (bfd_vma value
)
245 expld
.result
.valid_p
= TRUE
;
246 expld
.result
.value
= value
;
247 expld
.result
.str
= NULL
;
248 expld
.result
.section
= NULL
;
252 new_rel (bfd_vma value
, asection
*section
)
254 expld
.result
.valid_p
= TRUE
;
255 expld
.result
.value
= value
;
256 expld
.result
.str
= NULL
;
257 expld
.result
.section
= section
;
261 new_rel_from_abs (bfd_vma value
)
263 asection
*s
= expld
.section
;
265 expld
.rel_from_abs
= TRUE
;
266 expld
.result
.valid_p
= TRUE
;
267 expld
.result
.value
= value
- s
->vma
;
268 expld
.result
.str
= NULL
;
269 expld
.result
.section
= s
;
272 /* New-function for the definedness hash table. */
274 static struct bfd_hash_entry
*
275 definedness_newfunc (struct bfd_hash_entry
*entry
,
276 struct bfd_hash_table
*table ATTRIBUTE_UNUSED
,
277 const char *name ATTRIBUTE_UNUSED
)
279 struct definedness_hash_entry
*ret
= (struct definedness_hash_entry
*) entry
;
282 ret
= (struct definedness_hash_entry
*)
283 bfd_hash_allocate (table
, sizeof (struct definedness_hash_entry
));
286 einfo (_("%P%F: bfd_hash_allocate failed creating symbol %s\n"), name
);
294 /* Called during processing of linker script script expressions.
295 For symbols assigned in a linker script, return a struct describing
296 where the symbol is defined relative to the current expression,
297 otherwise return NULL. */
299 static struct definedness_hash_entry
*
300 symbol_defined (const char *name
)
302 return ((struct definedness_hash_entry
*)
303 bfd_hash_lookup (&definedness_table
, name
, FALSE
, FALSE
));
306 /* Update the definedness state of NAME. Return FALSE if script symbol
307 is multiply defining a strong symbol in an object. */
310 update_definedness (const char *name
, struct bfd_link_hash_entry
*h
)
313 struct definedness_hash_entry
*defentry
314 = (struct definedness_hash_entry
*)
315 bfd_hash_lookup (&definedness_table
, name
, TRUE
, FALSE
);
317 if (defentry
== NULL
)
318 einfo (_("%P%F: bfd_hash_lookup failed creating symbol %s\n"), name
);
320 /* If the symbol was already defined, and not by a script, then it
321 must be defined by an object file or by the linker target code. */
323 if (!defentry
->by_script
324 && (h
->type
== bfd_link_hash_defined
325 || h
->type
== bfd_link_hash_defweak
326 || h
->type
== bfd_link_hash_common
))
328 defentry
->by_object
= 1;
329 if (h
->type
== bfd_link_hash_defined
330 && h
->u
.def
.section
->output_section
!= NULL
335 defentry
->by_script
= 1;
336 defentry
->iteration
= lang_statement_iteration
;
337 defentry
->final_sec
= bfd_abs_section_ptr
;
338 if (expld
.phase
== lang_final_phase_enum
339 && expld
.rel_from_abs
340 && expld
.result
.section
== bfd_abs_section_ptr
)
341 defentry
->final_sec
= section_for_dot ();
346 fold_segment_end (seg_align_type
*seg
)
348 if (expld
.phase
== lang_first_phase_enum
349 || expld
.section
!= bfd_abs_section_ptr
)
351 expld
.result
.valid_p
= FALSE
;
353 else if (seg
->phase
== exp_seg_align_seen
354 || seg
->phase
== exp_seg_relro_seen
)
356 seg
->phase
= exp_seg_end_seen
;
357 seg
->end
= expld
.result
.value
;
359 else if (seg
->phase
== exp_seg_done
360 || seg
->phase
== exp_seg_adjust
361 || seg
->phase
== exp_seg_relro_adjust
)
366 expld
.result
.valid_p
= FALSE
;
370 fold_unary (etree_type
*tree
)
372 exp_fold_tree_1 (tree
->unary
.child
);
373 if (expld
.result
.valid_p
)
375 switch (tree
->type
.node_code
)
378 if (expld
.phase
!= lang_first_phase_enum
)
379 new_rel_from_abs (align_n (expld
.dot
, expld
.result
.value
));
381 expld
.result
.valid_p
= FALSE
;
393 expld
.result
.value
= ~expld
.result
.value
;
397 expld
.result
.value
= !expld
.result
.value
;
401 expld
.result
.value
= -expld
.result
.value
;
405 /* Return next place aligned to value. */
406 if (expld
.phase
!= lang_first_phase_enum
)
409 expld
.result
.value
= align_n (expld
.dot
, expld
.result
.value
);
412 expld
.result
.valid_p
= FALSE
;
415 case DATA_SEGMENT_END
:
416 fold_segment_end (&expld
.dataseg
);
426 /* Arithmetic operators, bitwise AND, bitwise OR and XOR keep the
427 section of one of their operands only when the other operand is a
428 plain number. Losing the section when operating on two symbols,
429 ie. a result of a plain number, is required for subtraction and
430 XOR. It's justifiable for the other operations on the grounds that
431 adding, multiplying etc. two section relative values does not
432 really make sense unless they are just treated as numbers.
433 The same argument could be made for many expressions involving one
434 symbol and a number. For example, "1 << x" and "100 / x" probably
435 should not be given the section of x. The trouble is that if we
436 fuss about such things the rules become complex and it is onerous
437 to document ld expression evaluation. */
439 arith_result_section (const etree_value_type
*lhs
)
441 if (expld
.result
.section
== lhs
->section
)
443 if (expld
.section
== bfd_abs_section_ptr
444 && !config
.sane_expr
)
445 /* Duplicate the insanity in exp_fold_tree_1 case etree_value. */
446 expld
.result
.section
= bfd_abs_section_ptr
;
448 expld
.result
.section
= NULL
;
453 fold_segment_align (seg_align_type
*seg
, etree_value_type
*lhs
)
455 seg
->relro
= exp_seg_relro_start
;
456 if (expld
.phase
== lang_first_phase_enum
457 || expld
.section
!= bfd_abs_section_ptr
)
458 expld
.result
.valid_p
= FALSE
;
461 bfd_vma maxpage
= lhs
->value
;
462 bfd_vma commonpage
= expld
.result
.value
;
464 expld
.result
.value
= align_n (expld
.dot
, maxpage
);
465 if (seg
->phase
== exp_seg_relro_adjust
)
466 expld
.result
.value
= seg
->base
;
467 else if (seg
->phase
== exp_seg_adjust
)
469 if (commonpage
< maxpage
)
470 expld
.result
.value
+= ((expld
.dot
+ commonpage
- 1)
471 & (maxpage
- commonpage
));
475 expld
.result
.value
+= expld
.dot
& (maxpage
- 1);
476 if (seg
->phase
== exp_seg_done
)
480 else if (seg
->phase
== exp_seg_none
)
482 seg
->phase
= exp_seg_align_seen
;
483 seg
->base
= expld
.result
.value
;
484 seg
->pagesize
= commonpage
;
485 seg
->maxpagesize
= maxpage
;
489 expld
.result
.valid_p
= FALSE
;
495 fold_segment_relro_end (seg_align_type
*seg
, etree_value_type
*lhs
)
497 /* Operands swapped! XXX_SEGMENT_RELRO_END(offset,exp) has offset
498 in expld.result and exp in lhs. */
499 seg
->relro
= exp_seg_relro_end
;
500 seg
->relro_offset
= expld
.result
.value
;
501 if (expld
.phase
== lang_first_phase_enum
502 || expld
.section
!= bfd_abs_section_ptr
)
503 expld
.result
.valid_p
= FALSE
;
504 else if (seg
->phase
== exp_seg_align_seen
505 || seg
->phase
== exp_seg_adjust
506 || seg
->phase
== exp_seg_relro_adjust
507 || seg
->phase
== exp_seg_done
)
509 if (seg
->phase
== exp_seg_align_seen
510 || seg
->phase
== exp_seg_relro_adjust
)
511 seg
->relro_end
= lhs
->value
+ expld
.result
.value
;
513 if (seg
->phase
== exp_seg_relro_adjust
514 && (seg
->relro_end
& (seg
->pagesize
- 1)))
516 seg
->relro_end
+= seg
->pagesize
- 1;
517 seg
->relro_end
&= ~(seg
->pagesize
- 1);
518 expld
.result
.value
= seg
->relro_end
- expld
.result
.value
;
521 expld
.result
.value
= lhs
->value
;
523 if (seg
->phase
== exp_seg_align_seen
)
524 seg
->phase
= exp_seg_relro_seen
;
527 expld
.result
.valid_p
= FALSE
;
531 fold_binary (etree_type
*tree
)
533 etree_value_type lhs
;
534 exp_fold_tree_1 (tree
->binary
.lhs
);
536 /* The SEGMENT_START operator is special because its first
537 operand is a string, not the name of a symbol. Note that the
538 operands have been swapped, so binary.lhs is second (default)
539 operand, binary.rhs is first operand. */
540 if (expld
.result
.valid_p
&& tree
->type
.node_code
== SEGMENT_START
)
542 const char *segment_name
;
545 /* Check to see if the user has overridden the default
547 segment_name
= tree
->binary
.rhs
->name
.name
;
548 for (seg
= segments
; seg
; seg
= seg
->next
)
549 if (strcmp (seg
->name
, segment_name
) == 0)
552 && config
.magic_demand_paged
553 && (seg
->value
% config
.maxpagesize
) != 0)
554 einfo (_("%P: warning: address of `%s' "
555 "isn't multiple of maximum page size\n"),
558 new_rel_from_abs (seg
->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%S %% 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%S / 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 memset (&expld
.result
, 0, sizeof (expld
.result
));
691 switch (tree
->type
.node_code
)
694 if (expld
.phase
!= lang_first_phase_enum
)
696 bfd_vma hdr_size
= 0;
697 /* Don't find the real header size if only marking sections;
698 The bfd function may cache incorrect data. */
699 if (expld
.phase
!= lang_mark_phase_enum
)
700 hdr_size
= bfd_sizeof_headers (link_info
.output_bfd
, &link_info
);
701 new_number (hdr_size
);
706 if (expld
.phase
!= lang_first_phase_enum
)
708 struct bfd_link_hash_entry
*h
;
709 struct definedness_hash_entry
*def
;
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
)
719 && ((def
= symbol_defined (tree
->name
.name
)) == NULL
721 || def
->iteration
== (lang_statement_iteration
& 1)));
726 if (expld
.assign_name
!= NULL
727 && strcmp (expld
.assign_name
, tree
->name
.name
) == 0)
729 /* Self-assignment is only allowed for absolute symbols
730 defined in a linker script. */
731 struct bfd_link_hash_entry
*h
;
732 struct definedness_hash_entry
*def
;
734 h
= bfd_wrapped_link_hash_lookup (link_info
.output_bfd
,
739 && (h
->type
== bfd_link_hash_defined
740 || h
->type
== bfd_link_hash_defweak
)
741 && h
->u
.def
.section
== bfd_abs_section_ptr
742 && (def
= symbol_defined (tree
->name
.name
)) != NULL
743 && def
->iteration
== (lang_statement_iteration
& 1)))
744 expld
.assign_name
= NULL
;
746 if (expld
.phase
== lang_first_phase_enum
)
748 else if (tree
->name
.name
[0] == '.' && tree
->name
.name
[1] == 0)
749 new_rel_from_abs (expld
.dot
);
752 struct bfd_link_hash_entry
*h
;
754 h
= bfd_wrapped_link_hash_lookup (link_info
.output_bfd
,
759 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
760 else if (h
->type
== bfd_link_hash_defined
761 || h
->type
== bfd_link_hash_defweak
)
763 asection
*output_section
;
765 output_section
= h
->u
.def
.section
->output_section
;
766 if (output_section
== NULL
)
768 if (expld
.phase
== lang_mark_phase_enum
)
769 new_rel (h
->u
.def
.value
, h
->u
.def
.section
);
771 einfo (_("%X%S: unresolvable symbol `%s'"
772 " referenced in expression\n"),
773 tree
, tree
->name
.name
);
775 else if (output_section
== bfd_abs_section_ptr
776 && (expld
.section
!= bfd_abs_section_ptr
777 || config
.sane_expr
))
778 new_number (h
->u
.def
.value
+ h
->u
.def
.section
->output_offset
);
780 new_rel (h
->u
.def
.value
+ h
->u
.def
.section
->output_offset
,
783 else if (expld
.phase
== lang_final_phase_enum
784 || (expld
.phase
!= lang_mark_phase_enum
785 && expld
.assigning_to_dot
))
786 einfo (_("%F%S: undefined symbol `%s'"
787 " referenced in expression\n"),
788 tree
, tree
->name
.name
);
789 else if (h
->type
== bfd_link_hash_new
)
791 h
->type
= bfd_link_hash_undefined
;
792 h
->u
.undef
.abfd
= NULL
;
793 if (h
->u
.undef
.next
== NULL
&& h
!= link_info
.hash
->undefs_tail
)
794 bfd_link_add_undef (link_info
.hash
, h
);
796 if (expld
.assign_src
== NULL
)
797 expld
.assign_src
= h
;
799 expld
.assign_src
= (struct bfd_link_hash_entry
*) 0 - 1;
804 if (expld
.phase
!= lang_first_phase_enum
)
806 lang_output_section_statement_type
*os
;
808 os
= lang_output_section_find (tree
->name
.name
);
811 if (expld
.phase
== lang_final_phase_enum
)
812 einfo (_("%F%S: undefined section `%s'"
813 " referenced in expression\n"),
814 tree
, tree
->name
.name
);
816 else if (os
->processed_vma
)
817 new_rel (0, os
->bfd_section
);
822 if (expld
.phase
!= lang_first_phase_enum
)
824 lang_output_section_statement_type
*os
;
826 os
= lang_output_section_find (tree
->name
.name
);
829 if (expld
.phase
== lang_final_phase_enum
)
830 einfo (_("%F%S: undefined section `%s'"
831 " referenced in expression\n"),
832 tree
, tree
->name
.name
);
834 else if (os
->processed_lma
)
836 if (os
->load_base
== NULL
)
837 new_abs (os
->bfd_section
->lma
);
840 exp_fold_tree_1 (os
->load_base
);
841 if (expld
.result
.valid_p
)
850 if (expld
.phase
!= lang_first_phase_enum
)
852 lang_output_section_statement_type
*os
;
854 os
= lang_output_section_find (tree
->name
.name
);
857 if (expld
.phase
== lang_final_phase_enum
)
858 einfo (_("%F%S: undefined section `%s'"
859 " referenced in expression\n"),
860 tree
, tree
->name
.name
);
863 else if (os
->bfd_section
!= NULL
)
867 if (tree
->type
.node_code
== SIZEOF
)
868 val
= (os
->bfd_section
->size
869 / bfd_octets_per_byte (link_info
.output_bfd
));
871 val
= (bfd_vma
)1 << os
->bfd_section
->alignment_power
;
882 if (expld
.phase
!= lang_first_phase_enum
)
884 lang_memory_region_type
*mem
;
886 mem
= lang_memory_region_lookup (tree
->name
.name
, FALSE
);
888 new_number (mem
->length
);
890 einfo (_("%F%S: undefined MEMORY region `%s'"
891 " referenced in expression\n"),
892 tree
, tree
->name
.name
);
898 if (expld
.phase
!= lang_first_phase_enum
)
900 lang_memory_region_type
*mem
;
902 mem
= lang_memory_region_lookup (tree
->name
.name
, FALSE
);
904 new_rel_from_abs (mem
->origin
);
906 einfo (_("%F%S: undefined MEMORY region `%s'"
907 " referenced in expression\n"),
908 tree
, tree
->name
.name
);
913 if (strcmp (tree
->name
.name
, "MAXPAGESIZE") == 0)
914 new_number (config
.maxpagesize
);
915 else if (strcmp (tree
->name
.name
, "COMMONPAGESIZE") == 0)
916 new_number (config
.commonpagesize
);
918 einfo (_("%F%S: unknown constant `%s' referenced in expression\n"),
919 tree
, tree
->name
.name
);
928 /* Return true if TREE is '.'. */
931 is_dot (const etree_type
*tree
)
933 return (tree
->type
.node_class
== etree_name
934 && tree
->type
.node_code
== NAME
935 && tree
->name
.name
[0] == '.'
936 && tree
->name
.name
[1] == 0);
939 /* Return true if TREE is a constant equal to VAL. */
942 is_value (const etree_type
*tree
, bfd_vma val
)
944 return (tree
->type
.node_class
== etree_value
945 && tree
->value
.value
== val
);
948 /* Return true if TREE is an absolute symbol equal to VAL defined in
952 is_sym_value (const etree_type
*tree
, bfd_vma val
)
954 struct bfd_link_hash_entry
*h
;
955 struct definedness_hash_entry
*def
;
957 return (tree
->type
.node_class
== etree_name
958 && tree
->type
.node_code
== NAME
959 && (def
= symbol_defined (tree
->name
.name
)) != NULL
961 && def
->iteration
== (lang_statement_iteration
& 1)
962 && (h
= bfd_wrapped_link_hash_lookup (link_info
.output_bfd
,
965 FALSE
, FALSE
, TRUE
)) != NULL
966 && h
->type
== bfd_link_hash_defined
967 && h
->u
.def
.section
== bfd_abs_section_ptr
968 && h
->u
.def
.value
== val
);
971 /* Return true if TREE is ". != 0". */
974 is_dot_ne_0 (const etree_type
*tree
)
976 return (tree
->type
.node_class
== etree_binary
977 && tree
->type
.node_code
== NE
978 && is_dot (tree
->binary
.lhs
)
979 && is_value (tree
->binary
.rhs
, 0));
982 /* Return true if TREE is ". = . + 0" or ". = . + sym" where sym is an
983 absolute constant with value 0 defined in a linker script. */
986 is_dot_plus_0 (const etree_type
*tree
)
988 return (tree
->type
.node_class
== etree_binary
989 && tree
->type
.node_code
== '+'
990 && is_dot (tree
->binary
.lhs
)
991 && (is_value (tree
->binary
.rhs
, 0)
992 || is_sym_value (tree
->binary
.rhs
, 0)));
995 /* Return true if TREE is "ALIGN (. != 0 ? some_expression : 1)". */
998 is_align_conditional (const etree_type
*tree
)
1000 if (tree
->type
.node_class
== etree_unary
1001 && tree
->type
.node_code
== ALIGN_K
)
1003 tree
= tree
->unary
.child
;
1004 return (tree
->type
.node_class
== etree_trinary
1005 && is_dot_ne_0 (tree
->trinary
.cond
)
1006 && is_value (tree
->trinary
.rhs
, 1));
1012 exp_fold_tree_1 (etree_type
*tree
)
1016 memset (&expld
.result
, 0, sizeof (expld
.result
));
1020 switch (tree
->type
.node_class
)
1023 if (expld
.section
== bfd_abs_section_ptr
1024 && !config
.sane_expr
)
1025 new_abs (tree
->value
.value
);
1027 new_number (tree
->value
.value
);
1028 expld
.result
.str
= tree
->value
.str
;
1032 if (expld
.phase
!= lang_first_phase_enum
)
1034 asection
*output_section
= tree
->rel
.section
->output_section
;
1035 new_rel (tree
->rel
.value
+ tree
->rel
.section
->output_offset
,
1039 memset (&expld
.result
, 0, sizeof (expld
.result
));
1043 exp_fold_tree_1 (tree
->assert_s
.child
);
1044 if (expld
.phase
== lang_final_phase_enum
&& !expld
.result
.value
)
1045 einfo ("%X%P: %s\n", tree
->assert_s
.message
);
1057 fold_trinary (tree
);
1062 case etree_provided
:
1063 if (tree
->assign
.dst
[0] == '.' && tree
->assign
.dst
[1] == 0)
1065 if (tree
->type
.node_class
!= etree_assign
)
1066 einfo (_("%F%S can not PROVIDE assignment to"
1067 " location counter\n"), tree
);
1068 if (expld
.phase
!= lang_first_phase_enum
)
1070 /* Notify the folder that this is an assignment to dot. */
1071 expld
.assigning_to_dot
= TRUE
;
1072 exp_fold_tree_1 (tree
->assign
.src
);
1073 expld
.assigning_to_dot
= FALSE
;
1075 /* If we are assigning to dot inside an output section
1076 arrange to keep the section, except for certain
1077 expressions that evaluate to zero. We ignore . = 0,
1078 . = . + 0, and . = ALIGN (. != 0 ? expr : 1).
1079 We can't ignore all expressions that evaluate to zero
1080 because an otherwise empty section might have padding
1081 added by an alignment expression that changes with
1082 relaxation. Such a section might have zero size
1083 before relaxation and so be stripped incorrectly. */
1084 if (expld
.phase
== lang_mark_phase_enum
1085 && expld
.section
!= bfd_abs_section_ptr
1086 && expld
.section
!= bfd_und_section_ptr
1087 && !(expld
.result
.valid_p
1088 && expld
.result
.value
== 0
1089 && (is_value (tree
->assign
.src
, 0)
1090 || is_sym_value (tree
->assign
.src
, 0)
1091 || is_dot_plus_0 (tree
->assign
.src
)
1092 || is_align_conditional (tree
->assign
.src
))))
1093 expld
.section
->flags
|= SEC_KEEP
;
1095 if (!expld
.result
.valid_p
1096 || expld
.section
== bfd_und_section_ptr
)
1098 if (expld
.phase
!= lang_mark_phase_enum
)
1099 einfo (_("%F%S invalid assignment to"
1100 " location counter\n"), tree
);
1102 else if (expld
.dotp
== NULL
)
1103 einfo (_("%F%S assignment to location counter"
1104 " invalid outside of SECTIONS\n"), tree
);
1106 /* After allocation, assignment to dot should not be
1107 done inside an output section since allocation adds a
1108 padding statement that effectively duplicates the
1110 else if (expld
.phase
<= lang_allocating_phase_enum
1111 || expld
.section
== bfd_abs_section_ptr
)
1115 nextdot
= expld
.result
.value
;
1116 if (expld
.result
.section
!= NULL
)
1117 nextdot
+= expld
.result
.section
->vma
;
1119 nextdot
+= expld
.section
->vma
;
1120 if (nextdot
< expld
.dot
1121 && expld
.section
!= bfd_abs_section_ptr
)
1122 einfo (_("%F%S cannot move location counter backwards"
1123 " (from %V to %V)\n"),
1124 tree
, expld
.dot
, nextdot
);
1127 expld
.dot
= nextdot
;
1128 *expld
.dotp
= nextdot
;
1133 memset (&expld
.result
, 0, sizeof (expld
.result
));
1137 struct bfd_link_hash_entry
*h
= NULL
;
1139 if (tree
->type
.node_class
== etree_provide
)
1141 h
= bfd_link_hash_lookup (link_info
.hash
, tree
->assign
.dst
,
1142 FALSE
, FALSE
, TRUE
);
1144 || !(h
->type
== bfd_link_hash_new
1145 || h
->type
== bfd_link_hash_undefined
1146 || h
->type
== bfd_link_hash_undefweak
1149 /* Do nothing. The symbol was never referenced, or
1150 was defined in some object file. Note that
1151 undefweak symbols are defined by PROVIDE. This
1152 is to support glibc use of __rela_iplt_start and
1153 similar weak references. */
1158 expld
.assign_name
= tree
->assign
.dst
;
1159 expld
.assign_src
= NULL
;
1160 exp_fold_tree_1 (tree
->assign
.src
);
1161 /* expld.assign_name remaining equal to tree->assign.dst
1162 below indicates the evaluation of tree->assign.src did
1163 not use the value of tree->assign.dst. We don't allow
1164 self assignment until the final phase for two reasons:
1165 1) Expressions are evaluated multiple times. With
1166 relaxation, the number of times may vary.
1167 2) Section relative symbol values cannot be correctly
1168 converted to absolute values, as is required by many
1169 expressions, until final section sizing is complete. */
1170 if ((expld
.result
.valid_p
1171 && (expld
.phase
== lang_final_phase_enum
1172 || expld
.assign_name
!= NULL
))
1173 || (expld
.phase
<= lang_mark_phase_enum
1174 && tree
->type
.node_class
== etree_assign
1175 && tree
->assign
.defsym
))
1179 h
= bfd_link_hash_lookup (link_info
.hash
, tree
->assign
.dst
,
1182 einfo (_("%P%F:%s: hash creation failed\n"),
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 h
->type
= bfd_link_hash_defined
;
1200 h
->u
.def
.value
= expld
.result
.value
;
1201 h
->u
.def
.section
= expld
.result
.section
;
1202 h
->linker_def
= ! tree
->assign
.type
.lineno
;
1203 h
->ldscript_def
= 1;
1204 if (tree
->type
.node_class
== etree_provide
)
1205 tree
->type
.node_class
= etree_provided
;
1207 /* Copy the symbol type if this is an expression only
1208 referencing a single symbol. (If the expression
1209 contains ternary conditions, ignoring symbols on
1211 if (expld
.result
.valid_p
1212 && expld
.assign_src
!= NULL
1213 && expld
.assign_src
!= (struct bfd_link_hash_entry
*) 0 - 1)
1214 bfd_copy_link_hash_symbol_type (link_info
.output_bfd
, h
,
1217 else if (expld
.phase
== lang_final_phase_enum
)
1219 h
= bfd_link_hash_lookup (link_info
.hash
, tree
->assign
.dst
,
1220 FALSE
, FALSE
, TRUE
);
1222 && h
->type
== bfd_link_hash_new
)
1223 h
->type
= bfd_link_hash_undefined
;
1225 expld
.assign_name
= NULL
;
1235 memset (&expld
.result
, 0, sizeof (expld
.result
));
1241 exp_fold_tree (etree_type
*tree
, asection
*current_section
, bfd_vma
*dotp
)
1243 expld
.rel_from_abs
= FALSE
;
1246 expld
.section
= current_section
;
1247 exp_fold_tree_1 (tree
);
1251 exp_fold_tree_no_dot (etree_type
*tree
)
1253 expld
.rel_from_abs
= FALSE
;
1256 expld
.section
= bfd_abs_section_ptr
;
1257 exp_fold_tree_1 (tree
);
1261 exp_value_fold (etree_type
*tree
)
1263 exp_fold_tree_no_dot (tree
);
1264 if (expld
.result
.valid_p
)
1266 tree
->type
.node_code
= INT
;
1267 tree
->value
.value
= expld
.result
.value
;
1268 tree
->value
.str
= NULL
;
1269 tree
->type
.node_class
= etree_value
;
1273 #define MAX(a, b) ((a) > (b) ? (a) : (b))
1276 exp_binop (int code
, etree_type
*lhs
, etree_type
*rhs
)
1278 etree_type
*new_e
= (etree_type
*) stat_alloc (MAX (sizeof (new_e
->binary
),
1279 sizeof (new_e
->value
)));
1280 new_e
->type
.node_code
= code
;
1281 new_e
->type
.filename
= lhs
->type
.filename
;
1282 new_e
->type
.lineno
= lhs
->type
.lineno
;
1283 new_e
->binary
.lhs
= lhs
;
1284 new_e
->binary
.rhs
= rhs
;
1285 new_e
->type
.node_class
= etree_binary
;
1286 if (lhs
->type
.node_class
== etree_value
1287 && rhs
->type
.node_class
== etree_value
1289 && code
!= DATA_SEGMENT_ALIGN
1290 && code
!= DATA_SEGMENT_RELRO_END
)
1291 exp_value_fold (new_e
);
1296 exp_trinop (int code
, etree_type
*cond
, etree_type
*lhs
, etree_type
*rhs
)
1298 etree_type
*new_e
= (etree_type
*) stat_alloc (MAX (sizeof (new_e
->trinary
),
1299 sizeof (new_e
->value
)));
1300 new_e
->type
.node_code
= code
;
1301 new_e
->type
.filename
= cond
->type
.filename
;
1302 new_e
->type
.lineno
= cond
->type
.lineno
;
1303 new_e
->trinary
.lhs
= lhs
;
1304 new_e
->trinary
.cond
= cond
;
1305 new_e
->trinary
.rhs
= rhs
;
1306 new_e
->type
.node_class
= etree_trinary
;
1307 if (cond
->type
.node_class
== etree_value
1308 && lhs
->type
.node_class
== etree_value
1309 && rhs
->type
.node_class
== etree_value
)
1310 exp_value_fold (new_e
);
1315 exp_unop (int code
, etree_type
*child
)
1317 etree_type
*new_e
= (etree_type
*) stat_alloc (MAX (sizeof (new_e
->unary
),
1318 sizeof (new_e
->value
)));
1319 new_e
->unary
.type
.node_code
= code
;
1320 new_e
->unary
.type
.filename
= child
->type
.filename
;
1321 new_e
->unary
.type
.lineno
= child
->type
.lineno
;
1322 new_e
->unary
.child
= child
;
1323 new_e
->unary
.type
.node_class
= etree_unary
;
1324 if (child
->type
.node_class
== etree_value
1328 && code
!= DATA_SEGMENT_END
)
1329 exp_value_fold (new_e
);
1334 exp_nameop (int code
, const char *name
)
1336 etree_type
*new_e
= (etree_type
*) stat_alloc (sizeof (new_e
->name
));
1338 new_e
->name
.type
.node_code
= code
;
1339 new_e
->name
.type
.filename
= ldlex_filename ();
1340 new_e
->name
.type
.lineno
= lineno
;
1341 new_e
->name
.name
= name
;
1342 new_e
->name
.type
.node_class
= etree_name
;
1348 exp_assop (const char *dst
,
1350 enum node_tree_enum
class,
1356 n
= (etree_type
*) stat_alloc (sizeof (n
->assign
));
1357 n
->assign
.type
.node_code
= '=';
1358 n
->assign
.type
.filename
= src
->type
.filename
;
1359 n
->assign
.type
.lineno
= src
->type
.lineno
;
1360 n
->assign
.type
.node_class
= class;
1361 n
->assign
.src
= src
;
1362 n
->assign
.dst
= dst
;
1363 n
->assign
.defsym
= defsym
;
1364 n
->assign
.hidden
= hidden
;
1368 /* Handle linker script assignments and HIDDEN. */
1371 exp_assign (const char *dst
, etree_type
*src
, bfd_boolean hidden
)
1373 return exp_assop (dst
, src
, etree_assign
, FALSE
, hidden
);
1376 /* Handle --defsym command-line option. */
1379 exp_defsym (const char *dst
, etree_type
*src
)
1381 return exp_assop (dst
, src
, etree_assign
, TRUE
, FALSE
);
1384 /* Handle PROVIDE. */
1387 exp_provide (const char *dst
, etree_type
*src
, bfd_boolean hidden
)
1389 return exp_assop (dst
, src
, etree_provide
, FALSE
, hidden
);
1392 /* Handle ASSERT. */
1395 exp_assert (etree_type
*exp
, const char *message
)
1399 n
= (etree_type
*) stat_alloc (sizeof (n
->assert_s
));
1400 n
->assert_s
.type
.node_code
= '!';
1401 n
->assert_s
.type
.filename
= exp
->type
.filename
;
1402 n
->assert_s
.type
.lineno
= exp
->type
.lineno
;
1403 n
->assert_s
.type
.node_class
= etree_assert
;
1404 n
->assert_s
.child
= exp
;
1405 n
->assert_s
.message
= message
;
1410 exp_print_tree (etree_type
*tree
)
1412 bfd_boolean function_like
;
1414 if (config
.map_file
== NULL
)
1415 config
.map_file
= stderr
;
1419 minfo ("NULL TREE\n");
1423 switch (tree
->type
.node_class
)
1426 minfo ("0x%v", tree
->value
.value
);
1429 if (tree
->rel
.section
->owner
!= NULL
)
1430 minfo ("%B:", tree
->rel
.section
->owner
);
1431 minfo ("%s+0x%v", tree
->rel
.section
->name
, tree
->rel
.value
);
1434 fputs (tree
->assign
.dst
, config
.map_file
);
1435 exp_print_token (tree
->type
.node_code
, TRUE
);
1436 exp_print_tree (tree
->assign
.src
);
1439 case etree_provided
:
1440 fprintf (config
.map_file
, "PROVIDE (%s, ", tree
->assign
.dst
);
1441 exp_print_tree (tree
->assign
.src
);
1442 fputc (')', config
.map_file
);
1445 function_like
= FALSE
;
1446 switch (tree
->type
.node_code
)
1451 case DATA_SEGMENT_ALIGN
:
1452 case DATA_SEGMENT_RELRO_END
:
1453 function_like
= TRUE
;
1456 /* Special handling because arguments are in reverse order and
1457 the segment name is quoted. */
1458 exp_print_token (tree
->type
.node_code
, FALSE
);
1459 fputs (" (\"", config
.map_file
);
1460 exp_print_tree (tree
->binary
.rhs
);
1461 fputs ("\", ", config
.map_file
);
1462 exp_print_tree (tree
->binary
.lhs
);
1463 fputc (')', config
.map_file
);
1468 exp_print_token (tree
->type
.node_code
, FALSE
);
1469 fputc (' ', config
.map_file
);
1471 fputc ('(', config
.map_file
);
1472 exp_print_tree (tree
->binary
.lhs
);
1474 fprintf (config
.map_file
, ", ");
1476 exp_print_token (tree
->type
.node_code
, TRUE
);
1477 exp_print_tree (tree
->binary
.rhs
);
1478 fputc (')', config
.map_file
);
1481 exp_print_tree (tree
->trinary
.cond
);
1482 fputc ('?', config
.map_file
);
1483 exp_print_tree (tree
->trinary
.lhs
);
1484 fputc (':', config
.map_file
);
1485 exp_print_tree (tree
->trinary
.rhs
);
1488 exp_print_token (tree
->unary
.type
.node_code
, FALSE
);
1489 if (tree
->unary
.child
)
1491 fprintf (config
.map_file
, " (");
1492 exp_print_tree (tree
->unary
.child
);
1493 fputc (')', config
.map_file
);
1498 fprintf (config
.map_file
, "ASSERT (");
1499 exp_print_tree (tree
->assert_s
.child
);
1500 fprintf (config
.map_file
, ", %s)", tree
->assert_s
.message
);
1504 if (tree
->type
.node_code
== NAME
)
1505 fputs (tree
->name
.name
, config
.map_file
);
1508 exp_print_token (tree
->type
.node_code
, FALSE
);
1509 if (tree
->name
.name
)
1510 fprintf (config
.map_file
, " (%s)", tree
->name
.name
);
1520 exp_get_vma (etree_type
*tree
, bfd_vma def
, char *name
)
1524 exp_fold_tree_no_dot (tree
);
1525 if (expld
.result
.valid_p
)
1526 return expld
.result
.value
;
1527 else if (name
!= NULL
&& expld
.phase
!= lang_mark_phase_enum
)
1528 einfo (_("%F%S: nonconstant expression for %s\n"),
1535 exp_get_value_int (etree_type
*tree
, int def
, char *name
)
1537 return exp_get_vma (tree
, def
, name
);
1541 exp_get_fill (etree_type
*tree
, fill_type
*def
, char *name
)
1550 exp_fold_tree_no_dot (tree
);
1551 if (!expld
.result
.valid_p
)
1553 if (name
!= NULL
&& expld
.phase
!= lang_mark_phase_enum
)
1554 einfo (_("%F%S: nonconstant expression for %s\n"),
1559 if (expld
.result
.str
!= NULL
&& (len
= strlen (expld
.result
.str
)) != 0)
1563 fill
= (fill_type
*) xmalloc ((len
+ 1) / 2 + sizeof (*fill
) - 1);
1564 fill
->size
= (len
+ 1) / 2;
1566 s
= (unsigned char *) expld
.result
.str
;
1574 digit
= (digit
- 'A' + '0' + 10) & 0xf;
1588 fill
= (fill_type
*) xmalloc (4 + sizeof (*fill
) - 1);
1589 val
= expld
.result
.value
;
1590 fill
->data
[0] = (val
>> 24) & 0xff;
1591 fill
->data
[1] = (val
>> 16) & 0xff;
1592 fill
->data
[2] = (val
>> 8) & 0xff;
1593 fill
->data
[3] = (val
>> 0) & 0xff;
1600 exp_get_abs_int (etree_type
*tree
, int def
, char *name
)
1604 exp_fold_tree_no_dot (tree
);
1606 if (expld
.result
.valid_p
)
1608 if (expld
.result
.section
!= NULL
)
1609 expld
.result
.value
+= expld
.result
.section
->vma
;
1610 return expld
.result
.value
;
1612 else if (name
!= NULL
&& expld
.phase
!= lang_mark_phase_enum
)
1614 einfo (_("%F%S: nonconstant expression for %s\n"),
1622 align_n (bfd_vma value
, bfd_vma align
)
1627 value
= (value
+ align
- 1) / align
;
1628 return value
* align
;
1634 /* The value "13" is ad-hoc, somewhat related to the expected number of
1635 assignments in a linker script. */
1636 if (!bfd_hash_table_init_n (&definedness_table
,
1637 definedness_newfunc
,
1638 sizeof (struct definedness_hash_entry
),
1640 einfo (_("%P%F: can not create hash table: %E\n"));
1643 /* Convert absolute symbols defined by a script from "dot" (also
1644 SEGMENT_START or ORIGIN) outside of an output section statement,
1645 to section relative. */
1648 set_sym_sections (struct bfd_hash_entry
*bh
, void *inf ATTRIBUTE_UNUSED
)
1650 struct definedness_hash_entry
*def
= (struct definedness_hash_entry
*) bh
;
1651 if (def
->final_sec
!= bfd_abs_section_ptr
)
1653 struct bfd_link_hash_entry
*h
;
1654 h
= bfd_link_hash_lookup (link_info
.hash
, bh
->string
,
1655 FALSE
, FALSE
, TRUE
);
1657 && h
->type
== bfd_link_hash_defined
1658 && h
->u
.def
.section
== bfd_abs_section_ptr
)
1660 h
->u
.def
.value
-= def
->final_sec
->vma
;
1661 h
->u
.def
.section
= def
->final_sec
;
1668 ldexp_finalize_syms (void)
1670 bfd_hash_traverse (&definedness_table
, set_sym_sections
, NULL
);
1676 bfd_hash_table_free (&definedness_table
);