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 exp_fold_tree_1 (tree
->trinary
.cond
);
677 if (expld
.result
.valid_p
)
678 exp_fold_tree_1 (expld
.result
.value
680 : tree
->trinary
.rhs
);
684 fold_name (etree_type
*tree
)
686 memset (&expld
.result
, 0, sizeof (expld
.result
));
688 switch (tree
->type
.node_code
)
691 if (expld
.phase
!= lang_first_phase_enum
)
693 bfd_vma hdr_size
= 0;
694 /* Don't find the real header size if only marking sections;
695 The bfd function may cache incorrect data. */
696 if (expld
.phase
!= lang_mark_phase_enum
)
697 hdr_size
= bfd_sizeof_headers (link_info
.output_bfd
, &link_info
);
698 new_number (hdr_size
);
703 if (expld
.phase
!= lang_first_phase_enum
)
705 struct bfd_link_hash_entry
*h
;
706 struct definedness_hash_entry
*def
;
708 h
= bfd_wrapped_link_hash_lookup (link_info
.output_bfd
,
712 new_number (h
!= NULL
713 && (h
->type
== bfd_link_hash_defined
714 || h
->type
== bfd_link_hash_defweak
715 || h
->type
== bfd_link_hash_common
)
716 && ((def
= symbol_defined (tree
->name
.name
)) == NULL
718 || def
->iteration
== (lang_statement_iteration
& 1)));
723 if (expld
.assign_name
!= NULL
724 && strcmp (expld
.assign_name
, tree
->name
.name
) == 0)
726 /* Self-assignment is only allowed for absolute symbols
727 defined in a linker script. */
728 struct bfd_link_hash_entry
*h
;
729 struct definedness_hash_entry
*def
;
731 h
= bfd_wrapped_link_hash_lookup (link_info
.output_bfd
,
736 && (h
->type
== bfd_link_hash_defined
737 || h
->type
== bfd_link_hash_defweak
)
738 && h
->u
.def
.section
== bfd_abs_section_ptr
739 && (def
= symbol_defined (tree
->name
.name
)) != NULL
740 && def
->iteration
== (lang_statement_iteration
& 1)))
741 expld
.assign_name
= NULL
;
743 if (expld
.phase
== lang_first_phase_enum
)
745 else if (tree
->name
.name
[0] == '.' && tree
->name
.name
[1] == 0)
746 new_rel_from_abs (expld
.dot
);
749 struct bfd_link_hash_entry
*h
;
751 h
= bfd_wrapped_link_hash_lookup (link_info
.output_bfd
,
756 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
757 else if (h
->type
== bfd_link_hash_defined
758 || h
->type
== bfd_link_hash_defweak
)
760 asection
*output_section
;
762 output_section
= h
->u
.def
.section
->output_section
;
763 if (output_section
== NULL
)
765 if (expld
.phase
== lang_mark_phase_enum
)
766 new_rel (h
->u
.def
.value
, h
->u
.def
.section
);
768 einfo (_("%X%S: unresolvable symbol `%s'"
769 " referenced in expression\n"),
770 tree
, tree
->name
.name
);
772 else if (output_section
== bfd_abs_section_ptr
773 && (expld
.section
!= bfd_abs_section_ptr
774 || config
.sane_expr
))
775 new_number (h
->u
.def
.value
+ h
->u
.def
.section
->output_offset
);
777 new_rel (h
->u
.def
.value
+ h
->u
.def
.section
->output_offset
,
780 else if (expld
.phase
== lang_final_phase_enum
781 || (expld
.phase
!= lang_mark_phase_enum
782 && expld
.assigning_to_dot
))
783 einfo (_("%F%S: undefined symbol `%s'"
784 " referenced in expression\n"),
785 tree
, tree
->name
.name
);
786 else if (h
->type
== bfd_link_hash_new
)
788 h
->type
= bfd_link_hash_undefined
;
789 h
->u
.undef
.abfd
= NULL
;
790 if (h
->u
.undef
.next
== NULL
&& h
!= link_info
.hash
->undefs_tail
)
791 bfd_link_add_undef (link_info
.hash
, h
);
797 if (expld
.phase
!= lang_first_phase_enum
)
799 lang_output_section_statement_type
*os
;
801 os
= lang_output_section_find (tree
->name
.name
);
804 if (expld
.phase
== lang_final_phase_enum
)
805 einfo (_("%F%S: undefined section `%s'"
806 " referenced in expression\n"),
807 tree
, tree
->name
.name
);
809 else if (os
->processed_vma
)
810 new_rel (0, os
->bfd_section
);
815 if (expld
.phase
!= lang_first_phase_enum
)
817 lang_output_section_statement_type
*os
;
819 os
= lang_output_section_find (tree
->name
.name
);
822 if (expld
.phase
== lang_final_phase_enum
)
823 einfo (_("%F%S: undefined section `%s'"
824 " referenced in expression\n"),
825 tree
, tree
->name
.name
);
827 else if (os
->processed_lma
)
829 if (os
->load_base
== NULL
)
830 new_abs (os
->bfd_section
->lma
);
833 exp_fold_tree_1 (os
->load_base
);
834 if (expld
.result
.valid_p
)
843 if (expld
.phase
!= lang_first_phase_enum
)
845 lang_output_section_statement_type
*os
;
847 os
= lang_output_section_find (tree
->name
.name
);
850 if (expld
.phase
== lang_final_phase_enum
)
851 einfo (_("%F%S: undefined section `%s'"
852 " referenced in expression\n"),
853 tree
, tree
->name
.name
);
856 else if (os
->bfd_section
!= NULL
)
860 if (tree
->type
.node_code
== SIZEOF
)
861 val
= (os
->bfd_section
->size
862 / bfd_octets_per_byte (link_info
.output_bfd
));
864 val
= (bfd_vma
)1 << os
->bfd_section
->alignment_power
;
875 if (expld
.phase
!= lang_first_phase_enum
)
877 lang_memory_region_type
*mem
;
879 mem
= lang_memory_region_lookup (tree
->name
.name
, FALSE
);
881 new_number (mem
->length
);
883 einfo (_("%F%S: undefined MEMORY region `%s'"
884 " referenced in expression\n"),
885 tree
, tree
->name
.name
);
891 if (expld
.phase
!= lang_first_phase_enum
)
893 lang_memory_region_type
*mem
;
895 mem
= lang_memory_region_lookup (tree
->name
.name
, FALSE
);
897 new_rel_from_abs (mem
->origin
);
899 einfo (_("%F%S: undefined MEMORY region `%s'"
900 " referenced in expression\n"),
901 tree
, tree
->name
.name
);
906 if (strcmp (tree
->name
.name
, "MAXPAGESIZE") == 0)
907 new_number (config
.maxpagesize
);
908 else if (strcmp (tree
->name
.name
, "COMMONPAGESIZE") == 0)
909 new_number (config
.commonpagesize
);
911 einfo (_("%F%S: unknown constant `%s' referenced in expression\n"),
912 tree
, tree
->name
.name
);
921 /* Return true if TREE is '.'. */
924 is_dot (const etree_type
*tree
)
926 return (tree
->type
.node_class
== etree_name
927 && tree
->type
.node_code
== NAME
928 && tree
->name
.name
[0] == '.'
929 && tree
->name
.name
[1] == 0);
932 /* Return true if TREE is a constant equal to VAL. */
935 is_value (const etree_type
*tree
, bfd_vma val
)
937 return (tree
->type
.node_class
== etree_value
938 && tree
->value
.value
== val
);
941 /* Return true if TREE is an absolute symbol equal to VAL defined in
945 is_sym_value (const etree_type
*tree
, bfd_vma val
)
947 struct bfd_link_hash_entry
*h
;
948 struct definedness_hash_entry
*def
;
950 return (tree
->type
.node_class
== etree_name
951 && tree
->type
.node_code
== NAME
952 && (def
= symbol_defined (tree
->name
.name
)) != NULL
954 && def
->iteration
== (lang_statement_iteration
& 1)
955 && (h
= bfd_wrapped_link_hash_lookup (link_info
.output_bfd
,
958 FALSE
, FALSE
, TRUE
)) != NULL
959 && h
->type
== bfd_link_hash_defined
960 && h
->u
.def
.section
== bfd_abs_section_ptr
961 && h
->u
.def
.value
== val
);
964 /* Return true if TREE is ". != 0". */
967 is_dot_ne_0 (const etree_type
*tree
)
969 return (tree
->type
.node_class
== etree_binary
970 && tree
->type
.node_code
== NE
971 && is_dot (tree
->binary
.lhs
)
972 && is_value (tree
->binary
.rhs
, 0));
975 /* Return true if TREE is ". = . + 0" or ". = . + sym" where sym is an
976 absolute constant with value 0 defined in a linker script. */
979 is_dot_plus_0 (const etree_type
*tree
)
981 return (tree
->type
.node_class
== etree_binary
982 && tree
->type
.node_code
== '+'
983 && is_dot (tree
->binary
.lhs
)
984 && (is_value (tree
->binary
.rhs
, 0)
985 || is_sym_value (tree
->binary
.rhs
, 0)));
988 /* Return true if TREE is "ALIGN (. != 0 ? some_expression : 1)". */
991 is_align_conditional (const etree_type
*tree
)
993 if (tree
->type
.node_class
== etree_unary
994 && tree
->type
.node_code
== ALIGN_K
)
996 tree
= tree
->unary
.child
;
997 return (tree
->type
.node_class
== etree_trinary
998 && is_dot_ne_0 (tree
->trinary
.cond
)
999 && is_value (tree
->trinary
.rhs
, 1));
1004 /* Subroutine of exp_fold_tree_1 for copying a symbol type. */
1007 try_copy_symbol_type (struct bfd_link_hash_entry
*h
, etree_type
*src
)
1009 struct bfd_link_hash_entry
*hsrc
;
1011 hsrc
= bfd_link_hash_lookup (link_info
.hash
, src
->name
.name
,
1012 FALSE
, FALSE
, TRUE
);
1014 bfd_copy_link_hash_symbol_type (link_info
.output_bfd
, h
, hsrc
);
1018 exp_fold_tree_1 (etree_type
*tree
)
1022 memset (&expld
.result
, 0, sizeof (expld
.result
));
1026 switch (tree
->type
.node_class
)
1029 if (expld
.section
== bfd_abs_section_ptr
1030 && !config
.sane_expr
)
1031 new_abs (tree
->value
.value
);
1033 new_number (tree
->value
.value
);
1034 expld
.result
.str
= tree
->value
.str
;
1038 if (expld
.phase
!= lang_first_phase_enum
)
1040 asection
*output_section
= tree
->rel
.section
->output_section
;
1041 new_rel (tree
->rel
.value
+ tree
->rel
.section
->output_offset
,
1045 memset (&expld
.result
, 0, sizeof (expld
.result
));
1049 exp_fold_tree_1 (tree
->assert_s
.child
);
1050 if (expld
.phase
== lang_final_phase_enum
&& !expld
.result
.value
)
1051 einfo ("%X%P: %s\n", tree
->assert_s
.message
);
1063 fold_trinary (tree
);
1068 case etree_provided
:
1069 if (tree
->assign
.dst
[0] == '.' && tree
->assign
.dst
[1] == 0)
1071 if (tree
->type
.node_class
!= etree_assign
)
1072 einfo (_("%F%S can not PROVIDE assignment to"
1073 " location counter\n"), tree
);
1074 if (expld
.phase
!= lang_first_phase_enum
)
1076 /* Notify the folder that this is an assignment to dot. */
1077 expld
.assigning_to_dot
= TRUE
;
1078 exp_fold_tree_1 (tree
->assign
.src
);
1079 expld
.assigning_to_dot
= FALSE
;
1081 /* If we are assigning to dot inside an output section
1082 arrange to keep the section, except for certain
1083 expressions that evaluate to zero. We ignore . = 0,
1084 . = . + 0, and . = ALIGN (. != 0 ? expr : 1).
1085 We can't ignore all expressions that evaluate to zero
1086 because an otherwise empty section might have padding
1087 added by an alignment expression that changes with
1088 relaxation. Such a section might have zero size
1089 before relaxation and so be stripped incorrectly. */
1090 if (expld
.phase
== lang_mark_phase_enum
1091 && expld
.section
!= bfd_abs_section_ptr
1092 && expld
.section
!= bfd_und_section_ptr
1093 && !(expld
.result
.valid_p
1094 && expld
.result
.value
== 0
1095 && (is_value (tree
->assign
.src
, 0)
1096 || is_sym_value (tree
->assign
.src
, 0)
1097 || is_dot_plus_0 (tree
->assign
.src
)
1098 || is_align_conditional (tree
->assign
.src
))))
1099 expld
.section
->flags
|= SEC_KEEP
;
1101 if (!expld
.result
.valid_p
1102 || expld
.section
== bfd_und_section_ptr
)
1104 if (expld
.phase
!= lang_mark_phase_enum
)
1105 einfo (_("%F%S invalid assignment to"
1106 " location counter\n"), tree
);
1108 else if (expld
.dotp
== NULL
)
1109 einfo (_("%F%S assignment to location counter"
1110 " invalid outside of SECTIONS\n"), tree
);
1112 /* After allocation, assignment to dot should not be
1113 done inside an output section since allocation adds a
1114 padding statement that effectively duplicates the
1116 else if (expld
.phase
<= lang_allocating_phase_enum
1117 || expld
.section
== bfd_abs_section_ptr
)
1121 nextdot
= expld
.result
.value
;
1122 if (expld
.result
.section
!= NULL
)
1123 nextdot
+= expld
.result
.section
->vma
;
1125 nextdot
+= expld
.section
->vma
;
1126 if (nextdot
< expld
.dot
1127 && expld
.section
!= bfd_abs_section_ptr
)
1128 einfo (_("%F%S cannot move location counter backwards"
1129 " (from %V to %V)\n"),
1130 tree
, expld
.dot
, nextdot
);
1133 expld
.dot
= nextdot
;
1134 *expld
.dotp
= nextdot
;
1139 memset (&expld
.result
, 0, sizeof (expld
.result
));
1143 struct bfd_link_hash_entry
*h
= NULL
;
1145 if (tree
->type
.node_class
== etree_provide
)
1147 h
= bfd_link_hash_lookup (link_info
.hash
, tree
->assign
.dst
,
1148 FALSE
, FALSE
, TRUE
);
1150 || !(h
->type
== bfd_link_hash_new
1151 || h
->type
== bfd_link_hash_undefined
1152 || h
->type
== bfd_link_hash_undefweak
1155 /* Do nothing. The symbol was never referenced, or
1156 was defined in some object file. Note that
1157 undefweak symbols are defined by PROVIDE. This
1158 is to support glibc use of __rela_iplt_start and
1159 similar weak references. */
1164 expld
.assign_name
= tree
->assign
.dst
;
1165 exp_fold_tree_1 (tree
->assign
.src
);
1166 /* expld.assign_name remaining equal to tree->assign.dst
1167 below indicates the evaluation of tree->assign.src did
1168 not use the value of tree->assign.dst. We don't allow
1169 self assignment until the final phase for two reasons:
1170 1) Expressions are evaluated multiple times. With
1171 relaxation, the number of times may vary.
1172 2) Section relative symbol values cannot be correctly
1173 converted to absolute values, as is required by many
1174 expressions, until final section sizing is complete. */
1175 if ((expld
.result
.valid_p
1176 && (expld
.phase
== lang_final_phase_enum
1177 || expld
.assign_name
!= NULL
))
1178 || (expld
.phase
<= lang_mark_phase_enum
1179 && tree
->type
.node_class
== etree_assign
1180 && tree
->assign
.defsym
))
1184 h
= bfd_link_hash_lookup (link_info
.hash
, tree
->assign
.dst
,
1187 einfo (_("%P%F:%s: hash creation failed\n"),
1191 if (expld
.result
.section
== NULL
)
1192 expld
.result
.section
= expld
.section
;
1193 if (!update_definedness (tree
->assign
.dst
, h
) && 0)
1195 /* Symbol was already defined. For now this error
1196 is disabled because it causes failures in the ld
1197 testsuite: ld-elf/var1, ld-scripts/defined5, and
1198 ld-scripts/pr14962. Some of these no doubt
1199 reflect scripts used in the wild. */
1200 (*link_info
.callbacks
->multiple_definition
)
1201 (&link_info
, h
, link_info
.output_bfd
,
1202 expld
.result
.section
, expld
.result
.value
);
1204 h
->type
= bfd_link_hash_defined
;
1205 h
->u
.def
.value
= expld
.result
.value
;
1206 h
->u
.def
.section
= expld
.result
.section
;
1207 h
->linker_def
= ! tree
->assign
.type
.lineno
;
1208 h
->ldscript_def
= 1;
1209 if (tree
->type
.node_class
== etree_provide
)
1210 tree
->type
.node_class
= etree_provided
;
1212 /* Copy the symbol type if this is a simple assignment of
1213 one symbol to another. Also, handle the case of a foldable
1214 ternary conditional with names on either side. */
1215 if (tree
->assign
.src
->type
.node_class
== etree_name
)
1216 try_copy_symbol_type (h
, tree
->assign
.src
);
1217 else if (tree
->assign
.src
->type
.node_class
== etree_trinary
)
1219 exp_fold_tree_1 (tree
->assign
.src
->trinary
.cond
);
1220 if (expld
.result
.valid_p
)
1222 if (expld
.result
.value
1223 && tree
->assign
.src
->trinary
.lhs
->type
.node_class
1225 try_copy_symbol_type (h
, tree
->assign
.src
->trinary
.lhs
);
1227 if (!expld
.result
.value
1228 && tree
->assign
.src
->trinary
.rhs
->type
.node_class
1230 try_copy_symbol_type (h
, tree
->assign
.src
->trinary
.rhs
);
1234 else if (expld
.phase
== lang_final_phase_enum
)
1236 h
= bfd_link_hash_lookup (link_info
.hash
, tree
->assign
.dst
,
1237 FALSE
, FALSE
, TRUE
);
1239 && h
->type
== bfd_link_hash_new
)
1240 h
->type
= bfd_link_hash_undefined
;
1242 expld
.assign_name
= NULL
;
1252 memset (&expld
.result
, 0, sizeof (expld
.result
));
1258 exp_fold_tree (etree_type
*tree
, asection
*current_section
, bfd_vma
*dotp
)
1260 expld
.rel_from_abs
= FALSE
;
1263 expld
.section
= current_section
;
1264 exp_fold_tree_1 (tree
);
1268 exp_fold_tree_no_dot (etree_type
*tree
)
1270 expld
.rel_from_abs
= FALSE
;
1273 expld
.section
= bfd_abs_section_ptr
;
1274 exp_fold_tree_1 (tree
);
1278 exp_value_fold (etree_type
*tree
)
1280 exp_fold_tree_no_dot (tree
);
1281 if (expld
.result
.valid_p
)
1283 tree
->type
.node_code
= INT
;
1284 tree
->value
.value
= expld
.result
.value
;
1285 tree
->value
.str
= NULL
;
1286 tree
->type
.node_class
= etree_value
;
1290 #define MAX(a, b) ((a) > (b) ? (a) : (b))
1293 exp_binop (int code
, etree_type
*lhs
, etree_type
*rhs
)
1295 etree_type
*new_e
= (etree_type
*) stat_alloc (MAX (sizeof (new_e
->binary
),
1296 sizeof (new_e
->value
)));
1297 new_e
->type
.node_code
= code
;
1298 new_e
->type
.filename
= lhs
->type
.filename
;
1299 new_e
->type
.lineno
= lhs
->type
.lineno
;
1300 new_e
->binary
.lhs
= lhs
;
1301 new_e
->binary
.rhs
= rhs
;
1302 new_e
->type
.node_class
= etree_binary
;
1303 if (lhs
->type
.node_class
== etree_value
1304 && rhs
->type
.node_class
== etree_value
1306 && code
!= DATA_SEGMENT_ALIGN
1307 && code
!= DATA_SEGMENT_RELRO_END
)
1308 exp_value_fold (new_e
);
1313 exp_trinop (int code
, etree_type
*cond
, etree_type
*lhs
, etree_type
*rhs
)
1315 etree_type
*new_e
= (etree_type
*) stat_alloc (MAX (sizeof (new_e
->trinary
),
1316 sizeof (new_e
->value
)));
1317 new_e
->type
.node_code
= code
;
1318 new_e
->type
.filename
= cond
->type
.filename
;
1319 new_e
->type
.lineno
= cond
->type
.lineno
;
1320 new_e
->trinary
.lhs
= lhs
;
1321 new_e
->trinary
.cond
= cond
;
1322 new_e
->trinary
.rhs
= rhs
;
1323 new_e
->type
.node_class
= etree_trinary
;
1324 if (cond
->type
.node_class
== etree_value
1325 && lhs
->type
.node_class
== etree_value
1326 && rhs
->type
.node_class
== etree_value
)
1327 exp_value_fold (new_e
);
1332 exp_unop (int code
, etree_type
*child
)
1334 etree_type
*new_e
= (etree_type
*) stat_alloc (MAX (sizeof (new_e
->unary
),
1335 sizeof (new_e
->value
)));
1336 new_e
->unary
.type
.node_code
= code
;
1337 new_e
->unary
.type
.filename
= child
->type
.filename
;
1338 new_e
->unary
.type
.lineno
= child
->type
.lineno
;
1339 new_e
->unary
.child
= child
;
1340 new_e
->unary
.type
.node_class
= etree_unary
;
1341 if (child
->type
.node_class
== etree_value
1345 && code
!= DATA_SEGMENT_END
)
1346 exp_value_fold (new_e
);
1351 exp_nameop (int code
, const char *name
)
1353 etree_type
*new_e
= (etree_type
*) stat_alloc (sizeof (new_e
->name
));
1355 new_e
->name
.type
.node_code
= code
;
1356 new_e
->name
.type
.filename
= ldlex_filename ();
1357 new_e
->name
.type
.lineno
= lineno
;
1358 new_e
->name
.name
= name
;
1359 new_e
->name
.type
.node_class
= etree_name
;
1365 exp_assop (const char *dst
,
1367 enum node_tree_enum
class,
1373 n
= (etree_type
*) stat_alloc (sizeof (n
->assign
));
1374 n
->assign
.type
.node_code
= '=';
1375 n
->assign
.type
.filename
= src
->type
.filename
;
1376 n
->assign
.type
.lineno
= src
->type
.lineno
;
1377 n
->assign
.type
.node_class
= class;
1378 n
->assign
.src
= src
;
1379 n
->assign
.dst
= dst
;
1380 n
->assign
.defsym
= defsym
;
1381 n
->assign
.hidden
= hidden
;
1385 /* Handle linker script assignments and HIDDEN. */
1388 exp_assign (const char *dst
, etree_type
*src
, bfd_boolean hidden
)
1390 return exp_assop (dst
, src
, etree_assign
, FALSE
, hidden
);
1393 /* Handle --defsym command-line option. */
1396 exp_defsym (const char *dst
, etree_type
*src
)
1398 return exp_assop (dst
, src
, etree_assign
, TRUE
, FALSE
);
1401 /* Handle PROVIDE. */
1404 exp_provide (const char *dst
, etree_type
*src
, bfd_boolean hidden
)
1406 return exp_assop (dst
, src
, etree_provide
, FALSE
, hidden
);
1409 /* Handle ASSERT. */
1412 exp_assert (etree_type
*exp
, const char *message
)
1416 n
= (etree_type
*) stat_alloc (sizeof (n
->assert_s
));
1417 n
->assert_s
.type
.node_code
= '!';
1418 n
->assert_s
.type
.filename
= exp
->type
.filename
;
1419 n
->assert_s
.type
.lineno
= exp
->type
.lineno
;
1420 n
->assert_s
.type
.node_class
= etree_assert
;
1421 n
->assert_s
.child
= exp
;
1422 n
->assert_s
.message
= message
;
1427 exp_print_tree (etree_type
*tree
)
1429 bfd_boolean function_like
;
1431 if (config
.map_file
== NULL
)
1432 config
.map_file
= stderr
;
1436 minfo ("NULL TREE\n");
1440 switch (tree
->type
.node_class
)
1443 minfo ("0x%v", tree
->value
.value
);
1446 if (tree
->rel
.section
->owner
!= NULL
)
1447 minfo ("%B:", tree
->rel
.section
->owner
);
1448 minfo ("%s+0x%v", tree
->rel
.section
->name
, tree
->rel
.value
);
1451 fputs (tree
->assign
.dst
, config
.map_file
);
1452 exp_print_token (tree
->type
.node_code
, TRUE
);
1453 exp_print_tree (tree
->assign
.src
);
1456 case etree_provided
:
1457 fprintf (config
.map_file
, "PROVIDE (%s, ", tree
->assign
.dst
);
1458 exp_print_tree (tree
->assign
.src
);
1459 fputc (')', config
.map_file
);
1462 function_like
= FALSE
;
1463 switch (tree
->type
.node_code
)
1468 case DATA_SEGMENT_ALIGN
:
1469 case DATA_SEGMENT_RELRO_END
:
1470 function_like
= TRUE
;
1473 /* Special handling because arguments are in reverse order and
1474 the segment name is quoted. */
1475 exp_print_token (tree
->type
.node_code
, FALSE
);
1476 fputs (" (\"", config
.map_file
);
1477 exp_print_tree (tree
->binary
.rhs
);
1478 fputs ("\", ", config
.map_file
);
1479 exp_print_tree (tree
->binary
.lhs
);
1480 fputc (')', config
.map_file
);
1485 exp_print_token (tree
->type
.node_code
, FALSE
);
1486 fputc (' ', config
.map_file
);
1488 fputc ('(', config
.map_file
);
1489 exp_print_tree (tree
->binary
.lhs
);
1491 fprintf (config
.map_file
, ", ");
1493 exp_print_token (tree
->type
.node_code
, TRUE
);
1494 exp_print_tree (tree
->binary
.rhs
);
1495 fputc (')', config
.map_file
);
1498 exp_print_tree (tree
->trinary
.cond
);
1499 fputc ('?', config
.map_file
);
1500 exp_print_tree (tree
->trinary
.lhs
);
1501 fputc (':', config
.map_file
);
1502 exp_print_tree (tree
->trinary
.rhs
);
1505 exp_print_token (tree
->unary
.type
.node_code
, FALSE
);
1506 if (tree
->unary
.child
)
1508 fprintf (config
.map_file
, " (");
1509 exp_print_tree (tree
->unary
.child
);
1510 fputc (')', config
.map_file
);
1515 fprintf (config
.map_file
, "ASSERT (");
1516 exp_print_tree (tree
->assert_s
.child
);
1517 fprintf (config
.map_file
, ", %s)", tree
->assert_s
.message
);
1521 if (tree
->type
.node_code
== NAME
)
1522 fputs (tree
->name
.name
, config
.map_file
);
1525 exp_print_token (tree
->type
.node_code
, FALSE
);
1526 if (tree
->name
.name
)
1527 fprintf (config
.map_file
, " (%s)", tree
->name
.name
);
1537 exp_get_vma (etree_type
*tree
, bfd_vma def
, char *name
)
1541 exp_fold_tree_no_dot (tree
);
1542 if (expld
.result
.valid_p
)
1543 return expld
.result
.value
;
1544 else if (name
!= NULL
&& expld
.phase
!= lang_mark_phase_enum
)
1545 einfo (_("%F%S: nonconstant expression for %s\n"),
1552 exp_get_value_int (etree_type
*tree
, int def
, char *name
)
1554 return exp_get_vma (tree
, def
, name
);
1558 exp_get_fill (etree_type
*tree
, fill_type
*def
, char *name
)
1567 exp_fold_tree_no_dot (tree
);
1568 if (!expld
.result
.valid_p
)
1570 if (name
!= NULL
&& expld
.phase
!= lang_mark_phase_enum
)
1571 einfo (_("%F%S: nonconstant expression for %s\n"),
1576 if (expld
.result
.str
!= NULL
&& (len
= strlen (expld
.result
.str
)) != 0)
1580 fill
= (fill_type
*) xmalloc ((len
+ 1) / 2 + sizeof (*fill
) - 1);
1581 fill
->size
= (len
+ 1) / 2;
1583 s
= (unsigned char *) expld
.result
.str
;
1591 digit
= (digit
- 'A' + '0' + 10) & 0xf;
1605 fill
= (fill_type
*) xmalloc (4 + sizeof (*fill
) - 1);
1606 val
= expld
.result
.value
;
1607 fill
->data
[0] = (val
>> 24) & 0xff;
1608 fill
->data
[1] = (val
>> 16) & 0xff;
1609 fill
->data
[2] = (val
>> 8) & 0xff;
1610 fill
->data
[3] = (val
>> 0) & 0xff;
1617 exp_get_abs_int (etree_type
*tree
, int def
, char *name
)
1621 exp_fold_tree_no_dot (tree
);
1623 if (expld
.result
.valid_p
)
1625 if (expld
.result
.section
!= NULL
)
1626 expld
.result
.value
+= expld
.result
.section
->vma
;
1627 return expld
.result
.value
;
1629 else if (name
!= NULL
&& expld
.phase
!= lang_mark_phase_enum
)
1631 einfo (_("%F%S: nonconstant expression for %s\n"),
1639 align_n (bfd_vma value
, bfd_vma align
)
1644 value
= (value
+ align
- 1) / align
;
1645 return value
* align
;
1651 /* The value "13" is ad-hoc, somewhat related to the expected number of
1652 assignments in a linker script. */
1653 if (!bfd_hash_table_init_n (&definedness_table
,
1654 definedness_newfunc
,
1655 sizeof (struct definedness_hash_entry
),
1657 einfo (_("%P%F: can not create hash table: %E\n"));
1660 /* Convert absolute symbols defined by a script from "dot" (also
1661 SEGMENT_START or ORIGIN) outside of an output section statement,
1662 to section relative. */
1665 set_sym_sections (struct bfd_hash_entry
*bh
, void *inf ATTRIBUTE_UNUSED
)
1667 struct definedness_hash_entry
*def
= (struct definedness_hash_entry
*) bh
;
1668 if (def
->final_sec
!= bfd_abs_section_ptr
)
1670 struct bfd_link_hash_entry
*h
;
1671 h
= bfd_link_hash_lookup (link_info
.hash
, bh
->string
,
1672 FALSE
, FALSE
, TRUE
);
1674 && h
->type
== bfd_link_hash_defined
1675 && h
->u
.def
.section
== bfd_abs_section_ptr
)
1677 h
->u
.def
.value
-= def
->final_sec
->vma
;
1678 h
->u
.def
.section
= def
->final_sec
;
1685 ldexp_finalize_syms (void)
1687 bfd_hash_traverse (&definedness_table
, set_sym_sections
, NULL
);
1693 bfd_hash_table_free (&definedness_table
);