1 /* This module handles expression trees.
2 Copyright (C) 1991-2018 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 /* Low bits of iteration count. Symbols with matching iteration have
64 been defined in this pass over the script. */
65 unsigned int iteration
: 8;
67 /* Symbol was defined by an object file. */
68 unsigned int by_object
: 1;
71 static struct bfd_hash_table definedness_table
;
73 /* Print the string representation of the given token. Surround it
74 with spaces if INFIX_P is TRUE. */
77 exp_print_token (token_code_type code
, int infix_p
)
104 { LOG2CEIL
, "LOG2CEIL" },
105 { ALIGN_K
, "ALIGN" },
112 { SECTIONS
, "SECTIONS" },
113 { SIZEOF_HEADERS
, "SIZEOF_HEADERS" },
114 { MEMORY
, "MEMORY" },
115 { DEFINED
, "DEFINED" },
116 { TARGET_K
, "TARGET" },
117 { SEARCH_DIR
, "SEARCH_DIR" },
121 { ALIGNOF
, "ALIGNOF" },
122 { SIZEOF
, "SIZEOF" },
124 { LOADADDR
, "LOADADDR" },
125 { CONSTANT
, "CONSTANT" },
126 { ABSOLUTE
, "ABSOLUTE" },
129 { ASSERT_K
, "ASSERT" },
130 { REL
, "relocatable" },
131 { DATA_SEGMENT_ALIGN
, "DATA_SEGMENT_ALIGN" },
132 { DATA_SEGMENT_RELRO_END
, "DATA_SEGMENT_RELRO_END" },
133 { DATA_SEGMENT_END
, "DATA_SEGMENT_END" },
134 { ORIGIN
, "ORIGIN" },
135 { LENGTH
, "LENGTH" },
136 { SEGMENT_START
, "SEGMENT_START" }
140 for (idx
= 0; idx
< ARRAY_SIZE (table
); idx
++)
141 if (table
[idx
].code
== code
)
145 fputc (' ', config
.map_file
);
147 if (idx
< ARRAY_SIZE (table
))
148 fputs (table
[idx
].name
, config
.map_file
);
150 fputc (code
, config
.map_file
);
152 fprintf (config
.map_file
, "<code %d>", code
);
155 fputc (' ', config
.map_file
);
161 bfd_vma value
= expld
.result
.value
;
163 bfd_boolean round_up
= FALSE
;
168 /* If more than one bit is set in the value we will need to round up. */
169 if ((value
> 1) && (value
& 1))
176 expld
.result
.section
= NULL
;
177 expld
.result
.value
= result
;
183 if (expld
.result
.section
!= NULL
)
184 expld
.result
.value
+= expld
.result
.section
->vma
;
185 expld
.result
.section
= bfd_abs_section_ptr
;
186 expld
.rel_from_abs
= FALSE
;
190 new_abs (bfd_vma value
)
192 expld
.result
.valid_p
= TRUE
;
193 expld
.result
.section
= bfd_abs_section_ptr
;
194 expld
.result
.value
= value
;
195 expld
.result
.str
= NULL
;
199 exp_intop (bfd_vma value
)
201 etree_type
*new_e
= (etree_type
*) stat_alloc (sizeof (new_e
->value
));
202 new_e
->type
.node_code
= INT
;
203 new_e
->type
.filename
= ldlex_filename ();
204 new_e
->type
.lineno
= lineno
;
205 new_e
->value
.value
= value
;
206 new_e
->value
.str
= NULL
;
207 new_e
->type
.node_class
= etree_value
;
212 exp_bigintop (bfd_vma value
, char *str
)
214 etree_type
*new_e
= (etree_type
*) stat_alloc (sizeof (new_e
->value
));
215 new_e
->type
.node_code
= INT
;
216 new_e
->type
.filename
= ldlex_filename ();
217 new_e
->type
.lineno
= lineno
;
218 new_e
->value
.value
= value
;
219 new_e
->value
.str
= str
;
220 new_e
->type
.node_class
= etree_value
;
224 /* Build an expression representing an unnamed relocatable value. */
227 exp_relop (asection
*section
, bfd_vma value
)
229 etree_type
*new_e
= (etree_type
*) stat_alloc (sizeof (new_e
->rel
));
230 new_e
->type
.node_code
= REL
;
231 new_e
->type
.filename
= ldlex_filename ();
232 new_e
->type
.lineno
= lineno
;
233 new_e
->type
.node_class
= etree_rel
;
234 new_e
->rel
.section
= section
;
235 new_e
->rel
.value
= value
;
240 new_number (bfd_vma value
)
242 expld
.result
.valid_p
= TRUE
;
243 expld
.result
.value
= value
;
244 expld
.result
.str
= NULL
;
245 expld
.result
.section
= NULL
;
249 new_rel (bfd_vma value
, asection
*section
)
251 expld
.result
.valid_p
= TRUE
;
252 expld
.result
.value
= value
;
253 expld
.result
.str
= NULL
;
254 expld
.result
.section
= section
;
258 new_rel_from_abs (bfd_vma value
)
260 asection
*s
= expld
.section
;
262 expld
.rel_from_abs
= TRUE
;
263 expld
.result
.valid_p
= TRUE
;
264 expld
.result
.value
= value
- s
->vma
;
265 expld
.result
.str
= NULL
;
266 expld
.result
.section
= s
;
269 /* New-function for the definedness hash table. */
271 static struct bfd_hash_entry
*
272 definedness_newfunc (struct bfd_hash_entry
*entry
,
273 struct bfd_hash_table
*table ATTRIBUTE_UNUSED
,
274 const char *name ATTRIBUTE_UNUSED
)
276 struct definedness_hash_entry
*ret
= (struct definedness_hash_entry
*) entry
;
279 ret
= (struct definedness_hash_entry
*)
280 bfd_hash_allocate (table
, sizeof (struct definedness_hash_entry
));
283 einfo (_("%F%P: bfd_hash_allocate failed creating symbol %s\n"), name
);
290 /* Called during processing of linker script script expressions.
291 For symbols assigned in a linker script, return a struct describing
292 where the symbol is defined relative to the current expression,
293 otherwise return NULL. */
295 static struct definedness_hash_entry
*
296 symbol_defined (const char *name
)
298 return ((struct definedness_hash_entry
*)
299 bfd_hash_lookup (&definedness_table
, name
, FALSE
, FALSE
));
302 /* Update the definedness state of NAME. Return FALSE if script symbol
303 is multiply defining a strong symbol in an object. */
306 update_definedness (const char *name
, struct bfd_link_hash_entry
*h
)
309 struct definedness_hash_entry
*defentry
310 = (struct definedness_hash_entry
*)
311 bfd_hash_lookup (&definedness_table
, name
, TRUE
, FALSE
);
313 if (defentry
== NULL
)
314 einfo (_("%F%P: bfd_hash_lookup failed creating symbol %s\n"), name
);
316 /* If the symbol was already defined, and not by a script, then it
317 must be defined by an object file or by the linker target code. */
320 && (h
->type
== bfd_link_hash_defined
321 || h
->type
== bfd_link_hash_defweak
322 || h
->type
== bfd_link_hash_common
))
324 defentry
->by_object
= 1;
325 if (h
->type
== bfd_link_hash_defined
326 && h
->u
.def
.section
->output_section
!= NULL
331 defentry
->iteration
= lang_statement_iteration
;
332 defentry
->final_sec
= bfd_abs_section_ptr
;
333 if (expld
.phase
== lang_final_phase_enum
334 && expld
.rel_from_abs
335 && expld
.result
.section
== bfd_abs_section_ptr
)
336 defentry
->final_sec
= section_for_dot ();
341 fold_segment_end (seg_align_type
*seg
)
343 if (expld
.phase
== lang_first_phase_enum
344 || expld
.section
!= bfd_abs_section_ptr
)
346 expld
.result
.valid_p
= FALSE
;
348 else if (seg
->phase
== exp_seg_align_seen
349 || seg
->phase
== exp_seg_relro_seen
)
351 seg
->phase
= exp_seg_end_seen
;
352 seg
->end
= expld
.result
.value
;
354 else if (seg
->phase
== exp_seg_done
355 || seg
->phase
== exp_seg_adjust
356 || seg
->phase
== exp_seg_relro_adjust
)
361 expld
.result
.valid_p
= FALSE
;
365 fold_unary (etree_type
*tree
)
367 exp_fold_tree_1 (tree
->unary
.child
);
368 if (expld
.result
.valid_p
)
370 switch (tree
->type
.node_code
)
373 if (expld
.phase
!= lang_first_phase_enum
)
374 new_rel_from_abs (align_n (expld
.dot
, expld
.result
.value
));
376 expld
.result
.valid_p
= FALSE
;
388 expld
.result
.value
= ~expld
.result
.value
;
392 expld
.result
.value
= !expld
.result
.value
;
396 expld
.result
.value
= -expld
.result
.value
;
400 /* Return next place aligned to value. */
401 if (expld
.phase
!= lang_first_phase_enum
)
404 expld
.result
.value
= align_n (expld
.dot
, expld
.result
.value
);
407 expld
.result
.valid_p
= FALSE
;
410 case DATA_SEGMENT_END
:
411 fold_segment_end (&expld
.dataseg
);
421 /* Arithmetic operators, bitwise AND, bitwise OR and XOR keep the
422 section of one of their operands only when the other operand is a
423 plain number. Losing the section when operating on two symbols,
424 ie. a result of a plain number, is required for subtraction and
425 XOR. It's justifiable for the other operations on the grounds that
426 adding, multiplying etc. two section relative values does not
427 really make sense unless they are just treated as numbers.
428 The same argument could be made for many expressions involving one
429 symbol and a number. For example, "1 << x" and "100 / x" probably
430 should not be given the section of x. The trouble is that if we
431 fuss about such things the rules become complex and it is onerous
432 to document ld expression evaluation. */
434 arith_result_section (const etree_value_type
*lhs
)
436 if (expld
.result
.section
== lhs
->section
)
438 if (expld
.section
== bfd_abs_section_ptr
439 && !config
.sane_expr
)
440 /* Duplicate the insanity in exp_fold_tree_1 case etree_value. */
441 expld
.result
.section
= bfd_abs_section_ptr
;
443 expld
.result
.section
= NULL
;
448 fold_segment_align (seg_align_type
*seg
, etree_value_type
*lhs
)
450 seg
->relro
= exp_seg_relro_start
;
451 if (expld
.phase
== lang_first_phase_enum
452 || expld
.section
!= bfd_abs_section_ptr
)
453 expld
.result
.valid_p
= FALSE
;
456 bfd_vma maxpage
= lhs
->value
;
457 bfd_vma commonpage
= expld
.result
.value
;
459 expld
.result
.value
= align_n (expld
.dot
, maxpage
);
460 if (seg
->phase
== exp_seg_relro_adjust
)
461 expld
.result
.value
= seg
->base
;
462 else if (seg
->phase
== exp_seg_adjust
)
464 if (commonpage
< maxpage
)
465 expld
.result
.value
+= ((expld
.dot
+ commonpage
- 1)
466 & (maxpage
- commonpage
));
470 expld
.result
.value
+= expld
.dot
& (maxpage
- 1);
471 if (seg
->phase
== exp_seg_done
)
475 else if (seg
->phase
== exp_seg_none
)
477 seg
->phase
= exp_seg_align_seen
;
478 seg
->base
= expld
.result
.value
;
479 seg
->pagesize
= commonpage
;
480 seg
->maxpagesize
= maxpage
;
484 expld
.result
.valid_p
= FALSE
;
490 fold_segment_relro_end (seg_align_type
*seg
, etree_value_type
*lhs
)
492 /* Operands swapped! XXX_SEGMENT_RELRO_END(offset,exp) has offset
493 in expld.result and exp in lhs. */
494 seg
->relro
= exp_seg_relro_end
;
495 seg
->relro_offset
= expld
.result
.value
;
496 if (expld
.phase
== lang_first_phase_enum
497 || expld
.section
!= bfd_abs_section_ptr
)
498 expld
.result
.valid_p
= FALSE
;
499 else if (seg
->phase
== exp_seg_align_seen
500 || seg
->phase
== exp_seg_adjust
501 || seg
->phase
== exp_seg_relro_adjust
502 || seg
->phase
== exp_seg_done
)
504 if (seg
->phase
== exp_seg_align_seen
505 || seg
->phase
== exp_seg_relro_adjust
)
506 seg
->relro_end
= lhs
->value
+ expld
.result
.value
;
508 if (seg
->phase
== exp_seg_relro_adjust
509 && (seg
->relro_end
& (seg
->pagesize
- 1)))
511 seg
->relro_end
+= seg
->pagesize
- 1;
512 seg
->relro_end
&= ~(seg
->pagesize
- 1);
513 expld
.result
.value
= seg
->relro_end
- expld
.result
.value
;
516 expld
.result
.value
= lhs
->value
;
518 if (seg
->phase
== exp_seg_align_seen
)
519 seg
->phase
= exp_seg_relro_seen
;
522 expld
.result
.valid_p
= FALSE
;
526 fold_binary (etree_type
*tree
)
528 etree_value_type lhs
;
529 exp_fold_tree_1 (tree
->binary
.lhs
);
531 /* The SEGMENT_START operator is special because its first
532 operand is a string, not the name of a symbol. Note that the
533 operands have been swapped, so binary.lhs is second (default)
534 operand, binary.rhs is first operand. */
535 if (expld
.result
.valid_p
&& tree
->type
.node_code
== SEGMENT_START
)
537 const char *segment_name
;
540 /* Check to see if the user has overridden the default
542 segment_name
= tree
->binary
.rhs
->name
.name
;
543 for (seg
= segments
; seg
; seg
= seg
->next
)
544 if (strcmp (seg
->name
, segment_name
) == 0)
547 && config
.magic_demand_paged
548 && config
.maxpagesize
!= 0
549 && (seg
->value
% config
.maxpagesize
) != 0)
550 einfo (_("%P: warning: address of `%s' "
551 "isn't multiple of maximum page size\n"),
554 new_rel_from_abs (seg
->value
);
561 exp_fold_tree_1 (tree
->binary
.rhs
);
562 expld
.result
.valid_p
&= lhs
.valid_p
;
564 if (expld
.result
.valid_p
)
566 if (lhs
.section
!= expld
.result
.section
)
568 /* If the values are from different sections, and neither is
569 just a number, make both the source arguments absolute. */
570 if (expld
.result
.section
!= NULL
571 && lhs
.section
!= NULL
)
574 lhs
.value
+= lhs
.section
->vma
;
575 lhs
.section
= bfd_abs_section_ptr
;
578 /* If the rhs is just a number, keep the lhs section. */
579 else if (expld
.result
.section
== NULL
)
581 expld
.result
.section
= lhs
.section
;
582 /* Make this NULL so that we know one of the operands
583 was just a number, for later tests. */
587 /* At this point we know that both operands have the same
588 section, or at least one of them is a plain number. */
590 switch (tree
->type
.node_code
)
594 expld.result.value = lhs.value y expld.result.value; \
595 arith_result_section (&lhs); \
598 /* Comparison operators, logical AND, and logical OR always
599 return a plain number. */
602 expld.result.value = lhs.value y expld.result.value; \
603 expld.result.section = NULL; \
624 if (expld
.result
.value
!= 0)
625 expld
.result
.value
= ((bfd_signed_vma
) lhs
.value
626 % (bfd_signed_vma
) expld
.result
.value
);
627 else if (expld
.phase
!= lang_mark_phase_enum
)
628 einfo (_("%F%P:%pS %% by zero\n"), tree
->binary
.rhs
);
629 arith_result_section (&lhs
);
633 if (expld
.result
.value
!= 0)
634 expld
.result
.value
= ((bfd_signed_vma
) lhs
.value
635 / (bfd_signed_vma
) expld
.result
.value
);
636 else if (expld
.phase
!= lang_mark_phase_enum
)
637 einfo (_("%F%P:%pS / by zero\n"), tree
->binary
.rhs
);
638 arith_result_section (&lhs
);
642 if (lhs
.value
> expld
.result
.value
)
643 expld
.result
.value
= lhs
.value
;
647 if (lhs
.value
< expld
.result
.value
)
648 expld
.result
.value
= lhs
.value
;
652 expld
.result
.value
= align_n (lhs
.value
, expld
.result
.value
);
655 case DATA_SEGMENT_ALIGN
:
656 fold_segment_align (&expld
.dataseg
, &lhs
);
659 case DATA_SEGMENT_RELRO_END
:
660 fold_segment_relro_end (&expld
.dataseg
, &lhs
);
670 fold_trinary (etree_type
*tree
)
672 struct bfd_link_hash_entry
*save
= expld
.assign_src
;
674 exp_fold_tree_1 (tree
->trinary
.cond
);
675 expld
.assign_src
= save
;
676 if (expld
.result
.valid_p
)
677 exp_fold_tree_1 (expld
.result
.value
679 : tree
->trinary
.rhs
);
683 fold_name (etree_type
*tree
)
685 struct bfd_link_hash_entry
*h
;
686 struct definedness_hash_entry
*def
;
688 memset (&expld
.result
, 0, sizeof (expld
.result
));
690 switch (tree
->type
.node_code
)
693 if (expld
.phase
!= lang_first_phase_enum
)
695 bfd_vma hdr_size
= 0;
696 /* Don't find the real header size if only marking sections;
697 The bfd function may cache incorrect data. */
698 if (expld
.phase
!= lang_mark_phase_enum
)
699 hdr_size
= bfd_sizeof_headers (link_info
.output_bfd
, &link_info
);
700 new_number (hdr_size
);
705 h
= bfd_wrapped_link_hash_lookup (link_info
.output_bfd
,
709 new_number (h
!= NULL
710 && (h
->type
== bfd_link_hash_defined
711 || h
->type
== bfd_link_hash_defweak
712 || h
->type
== bfd_link_hash_common
)
714 || (def
= symbol_defined (tree
->name
.name
)) == NULL
716 || def
->iteration
== (lang_statement_iteration
& 255)));
720 if (expld
.assign_name
!= NULL
721 && strcmp (expld
.assign_name
, tree
->name
.name
) == 0)
723 /* Self-assignment is only allowed for absolute symbols
724 defined in a linker script. */
725 h
= bfd_wrapped_link_hash_lookup (link_info
.output_bfd
,
730 && (h
->type
== bfd_link_hash_defined
731 || h
->type
== bfd_link_hash_defweak
)
732 && h
->u
.def
.section
== bfd_abs_section_ptr
733 && (def
= symbol_defined (tree
->name
.name
)) != NULL
734 && def
->iteration
== (lang_statement_iteration
& 255)))
735 expld
.assign_name
= NULL
;
737 if (tree
->name
.name
[0] == '.' && tree
->name
.name
[1] == 0)
738 new_rel_from_abs (expld
.dot
);
741 h
= bfd_wrapped_link_hash_lookup (link_info
.output_bfd
,
746 einfo (_("%F%P: bfd_link_hash_lookup failed: %E\n"));
747 else if (h
->type
== bfd_link_hash_defined
748 || h
->type
== bfd_link_hash_defweak
)
750 asection
*output_section
;
752 output_section
= h
->u
.def
.section
->output_section
;
753 if (output_section
== NULL
)
755 if (expld
.phase
<= lang_mark_phase_enum
)
756 new_rel (h
->u
.def
.value
, h
->u
.def
.section
);
758 einfo (_("%X%P:%pS: unresolvable symbol `%s'"
759 " referenced in expression\n"),
760 tree
, tree
->name
.name
);
762 else if (output_section
== bfd_abs_section_ptr
763 && (expld
.section
!= bfd_abs_section_ptr
764 || config
.sane_expr
))
765 new_number (h
->u
.def
.value
+ h
->u
.def
.section
->output_offset
);
767 new_rel (h
->u
.def
.value
+ h
->u
.def
.section
->output_offset
,
770 else if (expld
.phase
== lang_final_phase_enum
771 || (expld
.phase
!= lang_mark_phase_enum
772 && expld
.assigning_to_dot
))
773 einfo (_("%F%P:%pS: undefined symbol `%s'"
774 " referenced in expression\n"),
775 tree
, tree
->name
.name
);
776 else if (h
->type
== bfd_link_hash_new
)
778 h
->type
= bfd_link_hash_undefined
;
779 h
->u
.undef
.abfd
= NULL
;
780 if (h
->u
.undef
.next
== NULL
&& h
!= link_info
.hash
->undefs_tail
)
781 bfd_link_add_undef (link_info
.hash
, h
);
783 if (expld
.assign_src
== NULL
)
784 expld
.assign_src
= h
;
786 expld
.assign_src
= (struct bfd_link_hash_entry
*) - 1;
791 if (expld
.phase
!= lang_first_phase_enum
)
793 lang_output_section_statement_type
*os
;
795 os
= lang_output_section_find (tree
->name
.name
);
798 if (expld
.phase
== lang_final_phase_enum
)
799 einfo (_("%F%P:%pS: undefined section `%s'"
800 " referenced in expression\n"),
801 tree
, tree
->name
.name
);
803 else if (os
->processed_vma
)
804 new_rel (0, os
->bfd_section
);
809 if (expld
.phase
!= lang_first_phase_enum
)
811 lang_output_section_statement_type
*os
;
813 os
= lang_output_section_find (tree
->name
.name
);
816 if (expld
.phase
== lang_final_phase_enum
)
817 einfo (_("%F%P:%pS: undefined section `%s'"
818 " referenced in expression\n"),
819 tree
, tree
->name
.name
);
821 else if (os
->processed_lma
)
823 if (os
->load_base
== NULL
)
824 new_abs (os
->bfd_section
->lma
);
827 exp_fold_tree_1 (os
->load_base
);
828 if (expld
.result
.valid_p
)
837 if (expld
.phase
!= lang_first_phase_enum
)
839 lang_output_section_statement_type
*os
;
841 os
= lang_output_section_find (tree
->name
.name
);
844 if (expld
.phase
== lang_final_phase_enum
)
845 einfo (_("%F%P:%pS: undefined section `%s'"
846 " referenced in expression\n"),
847 tree
, tree
->name
.name
);
850 else if (os
->bfd_section
!= NULL
)
854 if (tree
->type
.node_code
== SIZEOF
)
855 val
= (os
->bfd_section
->size
856 / bfd_octets_per_byte (link_info
.output_bfd
));
858 val
= (bfd_vma
)1 << os
->bfd_section
->alignment_power
;
869 if (expld
.phase
!= lang_first_phase_enum
)
871 lang_memory_region_type
*mem
;
873 mem
= lang_memory_region_lookup (tree
->name
.name
, FALSE
);
875 new_number (mem
->length
);
877 einfo (_("%F%P:%pS: undefined MEMORY region `%s'"
878 " referenced in expression\n"),
879 tree
, tree
->name
.name
);
885 if (expld
.phase
!= lang_first_phase_enum
)
887 lang_memory_region_type
*mem
;
889 mem
= lang_memory_region_lookup (tree
->name
.name
, FALSE
);
891 new_rel_from_abs (mem
->origin
);
893 einfo (_("%F%P:%pS: undefined MEMORY region `%s'"
894 " referenced in expression\n"),
895 tree
, tree
->name
.name
);
900 if (strcmp (tree
->name
.name
, "MAXPAGESIZE") == 0)
901 new_number (config
.maxpagesize
);
902 else if (strcmp (tree
->name
.name
, "COMMONPAGESIZE") == 0)
903 new_number (config
.commonpagesize
);
905 einfo (_("%F%P:%pS: unknown constant `%s' referenced in expression\n"),
906 tree
, tree
->name
.name
);
915 /* Return true if TREE is '.'. */
918 is_dot (const etree_type
*tree
)
920 return (tree
->type
.node_class
== etree_name
921 && tree
->type
.node_code
== NAME
922 && tree
->name
.name
[0] == '.'
923 && tree
->name
.name
[1] == 0);
926 /* Return true if TREE is a constant equal to VAL. */
929 is_value (const etree_type
*tree
, bfd_vma val
)
931 return (tree
->type
.node_class
== etree_value
932 && tree
->value
.value
== val
);
935 /* Return true if TREE is an absolute symbol equal to VAL defined in
939 is_sym_value (const etree_type
*tree
, bfd_vma val
)
941 struct bfd_link_hash_entry
*h
;
942 struct definedness_hash_entry
*def
;
944 return (tree
->type
.node_class
== etree_name
945 && tree
->type
.node_code
== NAME
946 && (def
= symbol_defined (tree
->name
.name
)) != NULL
947 && def
->iteration
== (lang_statement_iteration
& 255)
948 && (h
= bfd_wrapped_link_hash_lookup (link_info
.output_bfd
,
951 FALSE
, FALSE
, TRUE
)) != NULL
953 && h
->type
== bfd_link_hash_defined
954 && h
->u
.def
.section
== bfd_abs_section_ptr
955 && h
->u
.def
.value
== val
);
958 /* Return true if TREE is ". != 0". */
961 is_dot_ne_0 (const etree_type
*tree
)
963 return (tree
->type
.node_class
== etree_binary
964 && tree
->type
.node_code
== NE
965 && is_dot (tree
->binary
.lhs
)
966 && is_value (tree
->binary
.rhs
, 0));
969 /* Return true if TREE is ". = . + 0" or ". = . + sym" where sym is an
970 absolute constant with value 0 defined in a linker script. */
973 is_dot_plus_0 (const etree_type
*tree
)
975 return (tree
->type
.node_class
== etree_binary
976 && tree
->type
.node_code
== '+'
977 && is_dot (tree
->binary
.lhs
)
978 && (is_value (tree
->binary
.rhs
, 0)
979 || is_sym_value (tree
->binary
.rhs
, 0)));
982 /* Return true if TREE is "ALIGN (. != 0 ? some_expression : 1)". */
985 is_align_conditional (const etree_type
*tree
)
987 if (tree
->type
.node_class
== etree_unary
988 && tree
->type
.node_code
== ALIGN_K
)
990 tree
= tree
->unary
.child
;
991 return (tree
->type
.node_class
== etree_trinary
992 && is_dot_ne_0 (tree
->trinary
.cond
)
993 && is_value (tree
->trinary
.rhs
, 1));
999 exp_fold_tree_1 (etree_type
*tree
)
1003 memset (&expld
.result
, 0, sizeof (expld
.result
));
1007 switch (tree
->type
.node_class
)
1010 if (expld
.section
== bfd_abs_section_ptr
1011 && !config
.sane_expr
)
1012 new_abs (tree
->value
.value
);
1014 new_number (tree
->value
.value
);
1015 expld
.result
.str
= tree
->value
.str
;
1019 if (expld
.phase
!= lang_first_phase_enum
)
1021 asection
*output_section
= tree
->rel
.section
->output_section
;
1022 new_rel (tree
->rel
.value
+ tree
->rel
.section
->output_offset
,
1026 memset (&expld
.result
, 0, sizeof (expld
.result
));
1030 exp_fold_tree_1 (tree
->assert_s
.child
);
1031 if (expld
.phase
== lang_final_phase_enum
&& !expld
.result
.value
)
1032 einfo ("%X%P: %s\n", tree
->assert_s
.message
);
1044 fold_trinary (tree
);
1049 case etree_provided
:
1050 if (tree
->assign
.dst
[0] == '.' && tree
->assign
.dst
[1] == 0)
1052 if (tree
->type
.node_class
!= etree_assign
)
1053 einfo (_("%F%P:%pS can not PROVIDE assignment to"
1054 " location counter\n"), tree
);
1055 if (expld
.phase
!= lang_first_phase_enum
)
1057 /* Notify the folder that this is an assignment to dot. */
1058 expld
.assigning_to_dot
= TRUE
;
1059 exp_fold_tree_1 (tree
->assign
.src
);
1060 expld
.assigning_to_dot
= FALSE
;
1062 /* If we are assigning to dot inside an output section
1063 arrange to keep the section, except for certain
1064 expressions that evaluate to zero. We ignore . = 0,
1065 . = . + 0, and . = ALIGN (. != 0 ? expr : 1).
1066 We can't ignore all expressions that evaluate to zero
1067 because an otherwise empty section might have padding
1068 added by an alignment expression that changes with
1069 relaxation. Such a section might have zero size
1070 before relaxation and so be stripped incorrectly. */
1071 if (expld
.phase
== lang_mark_phase_enum
1072 && expld
.section
!= bfd_abs_section_ptr
1073 && expld
.section
!= bfd_und_section_ptr
1074 && !(expld
.result
.valid_p
1075 && expld
.result
.value
== 0
1076 && (is_value (tree
->assign
.src
, 0)
1077 || is_sym_value (tree
->assign
.src
, 0)
1078 || is_dot_plus_0 (tree
->assign
.src
)
1079 || is_align_conditional (tree
->assign
.src
))))
1080 expld
.section
->flags
|= SEC_KEEP
;
1082 if (!expld
.result
.valid_p
1083 || expld
.section
== bfd_und_section_ptr
)
1085 if (expld
.phase
!= lang_mark_phase_enum
)
1086 einfo (_("%F%P:%pS invalid assignment to"
1087 " location counter\n"), tree
);
1089 else if (expld
.dotp
== NULL
)
1090 einfo (_("%F%P:%pS assignment to location counter"
1091 " invalid outside of SECTIONS\n"), tree
);
1093 /* After allocation, assignment to dot should not be
1094 done inside an output section since allocation adds a
1095 padding statement that effectively duplicates the
1097 else if (expld
.phase
<= lang_allocating_phase_enum
1098 || expld
.section
== bfd_abs_section_ptr
)
1102 nextdot
= expld
.result
.value
;
1103 if (expld
.result
.section
!= NULL
)
1104 nextdot
+= expld
.result
.section
->vma
;
1106 nextdot
+= expld
.section
->vma
;
1107 if (nextdot
< expld
.dot
1108 && expld
.section
!= bfd_abs_section_ptr
)
1109 einfo (_("%F%P:%pS cannot move location counter backwards"
1110 " (from %V to %V)\n"),
1111 tree
, expld
.dot
, nextdot
);
1114 expld
.dot
= nextdot
;
1115 *expld
.dotp
= nextdot
;
1120 memset (&expld
.result
, 0, sizeof (expld
.result
));
1124 struct bfd_link_hash_entry
*h
= NULL
;
1126 if (tree
->type
.node_class
== etree_provide
)
1128 h
= bfd_link_hash_lookup (link_info
.hash
, tree
->assign
.dst
,
1129 FALSE
, FALSE
, TRUE
);
1131 || !(h
->type
== bfd_link_hash_new
1132 || h
->type
== bfd_link_hash_undefined
1133 || h
->type
== bfd_link_hash_undefweak
1136 /* Do nothing. The symbol was never referenced, or
1137 was defined in some object file. Note that
1138 undefweak symbols are defined by PROVIDE. This
1139 is to support glibc use of __rela_iplt_start and
1140 similar weak references. */
1145 expld
.assign_name
= tree
->assign
.dst
;
1146 expld
.assign_src
= NULL
;
1147 exp_fold_tree_1 (tree
->assign
.src
);
1148 /* expld.assign_name remaining equal to tree->assign.dst
1149 below indicates the evaluation of tree->assign.src did
1150 not use the value of tree->assign.dst. We don't allow
1151 self assignment until the final phase for two reasons:
1152 1) Expressions are evaluated multiple times. With
1153 relaxation, the number of times may vary.
1154 2) Section relative symbol values cannot be correctly
1155 converted to absolute values, as is required by many
1156 expressions, until final section sizing is complete. */
1157 if (expld
.phase
== lang_final_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 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 h
->rel_from_abs
= expld
.rel_from_abs
;
1205 if (tree
->assign
.hidden
)
1206 bfd_link_hide_symbol (link_info
.output_bfd
,
1209 /* Copy the symbol type if this is an expression only
1210 referencing a single symbol. (If the expression
1211 contains ternary conditions, ignoring symbols on
1213 if (expld
.assign_src
!= NULL
1214 && (expld
.assign_src
1215 != (struct bfd_link_hash_entry
*) -1))
1216 bfd_copy_link_hash_symbol_type (link_info
.output_bfd
, h
,
1220 expld
.assign_name
= NULL
;
1230 memset (&expld
.result
, 0, sizeof (expld
.result
));
1236 exp_fold_tree (etree_type
*tree
, asection
*current_section
, bfd_vma
*dotp
)
1238 expld
.rel_from_abs
= FALSE
;
1241 expld
.section
= current_section
;
1242 exp_fold_tree_1 (tree
);
1246 exp_fold_tree_no_dot (etree_type
*tree
)
1248 expld
.rel_from_abs
= FALSE
;
1251 expld
.section
= bfd_abs_section_ptr
;
1252 exp_fold_tree_1 (tree
);
1256 exp_value_fold (etree_type
*tree
)
1258 exp_fold_tree_no_dot (tree
);
1259 if (expld
.result
.valid_p
)
1261 tree
->type
.node_code
= INT
;
1262 tree
->value
.value
= expld
.result
.value
;
1263 tree
->value
.str
= NULL
;
1264 tree
->type
.node_class
= etree_value
;
1268 #define MAX(a, b) ((a) > (b) ? (a) : (b))
1271 exp_binop (int code
, etree_type
*lhs
, etree_type
*rhs
)
1273 etree_type
*new_e
= (etree_type
*) stat_alloc (MAX (sizeof (new_e
->binary
),
1274 sizeof (new_e
->value
)));
1275 new_e
->type
.node_code
= code
;
1276 new_e
->type
.filename
= lhs
->type
.filename
;
1277 new_e
->type
.lineno
= lhs
->type
.lineno
;
1278 new_e
->binary
.lhs
= lhs
;
1279 new_e
->binary
.rhs
= rhs
;
1280 new_e
->type
.node_class
= etree_binary
;
1281 if (lhs
->type
.node_class
== etree_value
1282 && rhs
->type
.node_class
== etree_value
1284 && code
!= DATA_SEGMENT_ALIGN
1285 && code
!= DATA_SEGMENT_RELRO_END
)
1286 exp_value_fold (new_e
);
1291 exp_trinop (int code
, etree_type
*cond
, etree_type
*lhs
, etree_type
*rhs
)
1293 etree_type
*new_e
= (etree_type
*) stat_alloc (MAX (sizeof (new_e
->trinary
),
1294 sizeof (new_e
->value
)));
1295 new_e
->type
.node_code
= code
;
1296 new_e
->type
.filename
= cond
->type
.filename
;
1297 new_e
->type
.lineno
= cond
->type
.lineno
;
1298 new_e
->trinary
.lhs
= lhs
;
1299 new_e
->trinary
.cond
= cond
;
1300 new_e
->trinary
.rhs
= rhs
;
1301 new_e
->type
.node_class
= etree_trinary
;
1302 if (cond
->type
.node_class
== etree_value
1303 && lhs
->type
.node_class
== etree_value
1304 && rhs
->type
.node_class
== etree_value
)
1305 exp_value_fold (new_e
);
1310 exp_unop (int code
, etree_type
*child
)
1312 etree_type
*new_e
= (etree_type
*) stat_alloc (MAX (sizeof (new_e
->unary
),
1313 sizeof (new_e
->value
)));
1314 new_e
->unary
.type
.node_code
= code
;
1315 new_e
->unary
.type
.filename
= child
->type
.filename
;
1316 new_e
->unary
.type
.lineno
= child
->type
.lineno
;
1317 new_e
->unary
.child
= child
;
1318 new_e
->unary
.type
.node_class
= etree_unary
;
1319 if (child
->type
.node_class
== etree_value
1323 && code
!= DATA_SEGMENT_END
)
1324 exp_value_fold (new_e
);
1329 exp_nameop (int code
, const char *name
)
1331 etree_type
*new_e
= (etree_type
*) stat_alloc (sizeof (new_e
->name
));
1333 new_e
->name
.type
.node_code
= code
;
1334 new_e
->name
.type
.filename
= ldlex_filename ();
1335 new_e
->name
.type
.lineno
= lineno
;
1336 new_e
->name
.name
= name
;
1337 new_e
->name
.type
.node_class
= etree_name
;
1343 exp_assop (const char *dst
,
1345 enum node_tree_enum
class,
1350 n
= (etree_type
*) stat_alloc (sizeof (n
->assign
));
1351 n
->assign
.type
.node_code
= '=';
1352 n
->assign
.type
.filename
= src
->type
.filename
;
1353 n
->assign
.type
.lineno
= src
->type
.lineno
;
1354 n
->assign
.type
.node_class
= class;
1355 n
->assign
.src
= src
;
1356 n
->assign
.dst
= dst
;
1357 n
->assign
.hidden
= hidden
;
1361 /* Handle linker script assignments and HIDDEN. */
1364 exp_assign (const char *dst
, etree_type
*src
, bfd_boolean hidden
)
1366 return exp_assop (dst
, src
, etree_assign
, hidden
);
1369 /* Handle --defsym command-line option. */
1372 exp_defsym (const char *dst
, etree_type
*src
)
1374 return exp_assop (dst
, src
, etree_assign
, FALSE
);
1377 /* Handle PROVIDE. */
1380 exp_provide (const char *dst
, etree_type
*src
, bfd_boolean hidden
)
1382 return exp_assop (dst
, src
, etree_provide
, hidden
);
1385 /* Handle ASSERT. */
1388 exp_assert (etree_type
*exp
, const char *message
)
1392 n
= (etree_type
*) stat_alloc (sizeof (n
->assert_s
));
1393 n
->assert_s
.type
.node_code
= '!';
1394 n
->assert_s
.type
.filename
= exp
->type
.filename
;
1395 n
->assert_s
.type
.lineno
= exp
->type
.lineno
;
1396 n
->assert_s
.type
.node_class
= etree_assert
;
1397 n
->assert_s
.child
= exp
;
1398 n
->assert_s
.message
= message
;
1403 exp_print_tree (etree_type
*tree
)
1405 bfd_boolean function_like
;
1407 if (config
.map_file
== NULL
)
1408 config
.map_file
= stderr
;
1412 minfo ("NULL TREE\n");
1416 switch (tree
->type
.node_class
)
1419 minfo ("0x%v", tree
->value
.value
);
1422 if (tree
->rel
.section
->owner
!= NULL
)
1423 minfo ("%pB:", tree
->rel
.section
->owner
);
1424 minfo ("%s+0x%v", tree
->rel
.section
->name
, tree
->rel
.value
);
1427 fputs (tree
->assign
.dst
, config
.map_file
);
1428 exp_print_token (tree
->type
.node_code
, TRUE
);
1429 exp_print_tree (tree
->assign
.src
);
1432 case etree_provided
:
1433 fprintf (config
.map_file
, "PROVIDE (%s = ", tree
->assign
.dst
);
1434 exp_print_tree (tree
->assign
.src
);
1435 fputc (')', config
.map_file
);
1438 function_like
= FALSE
;
1439 switch (tree
->type
.node_code
)
1444 case DATA_SEGMENT_ALIGN
:
1445 case DATA_SEGMENT_RELRO_END
:
1446 function_like
= TRUE
;
1449 /* Special handling because arguments are in reverse order and
1450 the segment name is quoted. */
1451 exp_print_token (tree
->type
.node_code
, FALSE
);
1452 fputs (" (\"", config
.map_file
);
1453 exp_print_tree (tree
->binary
.rhs
);
1454 fputs ("\", ", config
.map_file
);
1455 exp_print_tree (tree
->binary
.lhs
);
1456 fputc (')', config
.map_file
);
1461 exp_print_token (tree
->type
.node_code
, FALSE
);
1462 fputc (' ', config
.map_file
);
1464 fputc ('(', config
.map_file
);
1465 exp_print_tree (tree
->binary
.lhs
);
1467 fprintf (config
.map_file
, ", ");
1469 exp_print_token (tree
->type
.node_code
, TRUE
);
1470 exp_print_tree (tree
->binary
.rhs
);
1471 fputc (')', config
.map_file
);
1474 exp_print_tree (tree
->trinary
.cond
);
1475 fputc ('?', config
.map_file
);
1476 exp_print_tree (tree
->trinary
.lhs
);
1477 fputc (':', config
.map_file
);
1478 exp_print_tree (tree
->trinary
.rhs
);
1481 exp_print_token (tree
->unary
.type
.node_code
, FALSE
);
1482 if (tree
->unary
.child
)
1484 fprintf (config
.map_file
, " (");
1485 exp_print_tree (tree
->unary
.child
);
1486 fputc (')', config
.map_file
);
1491 fprintf (config
.map_file
, "ASSERT (");
1492 exp_print_tree (tree
->assert_s
.child
);
1493 fprintf (config
.map_file
, ", %s)", tree
->assert_s
.message
);
1497 if (tree
->type
.node_code
== NAME
)
1498 fputs (tree
->name
.name
, config
.map_file
);
1501 exp_print_token (tree
->type
.node_code
, FALSE
);
1502 if (tree
->name
.name
)
1503 fprintf (config
.map_file
, " (%s)", tree
->name
.name
);
1513 exp_get_vma (etree_type
*tree
, bfd_vma def
, char *name
)
1517 exp_fold_tree_no_dot (tree
);
1518 if (expld
.result
.valid_p
)
1519 return expld
.result
.value
;
1520 else if (name
!= NULL
&& expld
.phase
!= lang_mark_phase_enum
)
1521 einfo (_("%F%P:%pS: nonconstant expression for %s\n"),
1527 /* Return the smallest non-negative integer such that two raised to
1528 that power is at least as large as the vma evaluated at TREE, if
1529 TREE is a non-NULL expression that can be resolved. If TREE is
1530 NULL or cannot be resolved, return -1. */
1533 exp_get_power (etree_type
*tree
, char *name
)
1535 bfd_vma x
= exp_get_vma (tree
, -1, name
);
1539 if (x
== (bfd_vma
) -1)
1542 for (n
= 0, p2
= 1; p2
< x
; ++n
, p2
<<= 1)
1550 exp_get_fill (etree_type
*tree
, fill_type
*def
, char *name
)
1559 exp_fold_tree_no_dot (tree
);
1560 if (!expld
.result
.valid_p
)
1562 if (name
!= NULL
&& expld
.phase
!= lang_mark_phase_enum
)
1563 einfo (_("%F%P:%pS: nonconstant expression for %s\n"),
1568 if (expld
.result
.str
!= NULL
&& (len
= strlen (expld
.result
.str
)) != 0)
1572 fill
= (fill_type
*) xmalloc ((len
+ 1) / 2 + sizeof (*fill
) - 1);
1573 fill
->size
= (len
+ 1) / 2;
1575 s
= (unsigned char *) expld
.result
.str
;
1583 digit
= (digit
- 'A' + '0' + 10) & 0xf;
1597 fill
= (fill_type
*) xmalloc (4 + sizeof (*fill
) - 1);
1598 val
= expld
.result
.value
;
1599 fill
->data
[0] = (val
>> 24) & 0xff;
1600 fill
->data
[1] = (val
>> 16) & 0xff;
1601 fill
->data
[2] = (val
>> 8) & 0xff;
1602 fill
->data
[3] = (val
>> 0) & 0xff;
1609 exp_get_abs_int (etree_type
*tree
, int def
, char *name
)
1613 exp_fold_tree_no_dot (tree
);
1615 if (expld
.result
.valid_p
)
1617 if (expld
.result
.section
!= NULL
)
1618 expld
.result
.value
+= expld
.result
.section
->vma
;
1619 return expld
.result
.value
;
1621 else if (name
!= NULL
&& expld
.phase
!= lang_mark_phase_enum
)
1623 einfo (_("%F%P:%pS: nonconstant expression for %s\n"),
1631 align_n (bfd_vma value
, bfd_vma align
)
1636 value
= (value
+ align
- 1) / align
;
1637 return value
* align
;
1643 /* The value "13" is ad-hoc, somewhat related to the expected number of
1644 assignments in a linker script. */
1645 if (!bfd_hash_table_init_n (&definedness_table
,
1646 definedness_newfunc
,
1647 sizeof (struct definedness_hash_entry
),
1649 einfo (_("%F%P: can not create hash table: %E\n"));
1652 /* Convert absolute symbols defined by a script from "dot" (also
1653 SEGMENT_START or ORIGIN) outside of an output section statement,
1654 to section relative. */
1657 set_sym_sections (struct bfd_hash_entry
*bh
, void *inf ATTRIBUTE_UNUSED
)
1659 struct definedness_hash_entry
*def
= (struct definedness_hash_entry
*) bh
;
1660 if (def
->final_sec
!= bfd_abs_section_ptr
)
1662 struct bfd_link_hash_entry
*h
;
1663 h
= bfd_link_hash_lookup (link_info
.hash
, bh
->string
,
1664 FALSE
, FALSE
, TRUE
);
1666 && h
->type
== bfd_link_hash_defined
1667 && h
->u
.def
.section
== bfd_abs_section_ptr
)
1669 h
->u
.def
.value
-= def
->final_sec
->vma
;
1670 h
->u
.def
.section
= def
->final_sec
;
1677 ldexp_finalize_syms (void)
1679 bfd_hash_traverse (&definedness_table
, set_sym_sections
, NULL
);
1685 bfd_hash_table_free (&definedness_table
);