1 /* This module handles expression trees.
2 Copyright (C) 1991-2015 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. */
54 struct definedness_hash_entry
56 struct bfd_hash_entry root
;
57 unsigned int by_object
: 1;
58 unsigned int by_script
: 1;
59 unsigned int iteration
: 1;
62 static struct bfd_hash_table definedness_table
;
64 /* Print the string representation of the given token. Surround it
65 with spaces if INFIX_P is TRUE. */
68 exp_print_token (token_code_type code
, int infix_p
)
95 { LOG2CEIL
, "LOG2CEIL" },
103 { SECTIONS
, "SECTIONS" },
104 { SIZEOF_HEADERS
, "SIZEOF_HEADERS" },
105 { MEMORY
, "MEMORY" },
106 { DEFINED
, "DEFINED" },
107 { TARGET_K
, "TARGET" },
108 { SEARCH_DIR
, "SEARCH_DIR" },
112 { ALIGNOF
, "ALIGNOF" },
113 { SIZEOF
, "SIZEOF" },
115 { LOADADDR
, "LOADADDR" },
116 { CONSTANT
, "CONSTANT" },
117 { ABSOLUTE
, "ABSOLUTE" },
120 { ASSERT_K
, "ASSERT" },
121 { REL
, "relocatable" },
122 { DATA_SEGMENT_ALIGN
, "DATA_SEGMENT_ALIGN" },
123 { DATA_SEGMENT_RELRO_END
, "DATA_SEGMENT_RELRO_END" },
124 { DATA_SEGMENT_END
, "DATA_SEGMENT_END" },
125 { ORIGIN
, "ORIGIN" },
126 { LENGTH
, "LENGTH" },
127 { SEGMENT_START
, "SEGMENT_START" }
131 for (idx
= 0; idx
< ARRAY_SIZE (table
); idx
++)
132 if (table
[idx
].code
== code
)
136 fputc (' ', config
.map_file
);
138 if (idx
< ARRAY_SIZE (table
))
139 fputs (table
[idx
].name
, config
.map_file
);
141 fputc (code
, config
.map_file
);
143 fprintf (config
.map_file
, "<code %d>", code
);
146 fputc (' ', config
.map_file
);
152 bfd_vma value
= expld
.result
.value
;
154 bfd_boolean round_up
= FALSE
;
159 /* If more than one bit is set in the value we will need to round up. */
160 if ((value
> 1) && (value
& 1))
167 expld
.result
.section
= NULL
;
168 expld
.result
.value
= result
;
174 if (expld
.result
.section
!= NULL
)
175 expld
.result
.value
+= expld
.result
.section
->vma
;
176 expld
.result
.section
= bfd_abs_section_ptr
;
180 new_abs (bfd_vma value
)
182 expld
.result
.valid_p
= TRUE
;
183 expld
.result
.section
= bfd_abs_section_ptr
;
184 expld
.result
.value
= value
;
185 expld
.result
.str
= NULL
;
189 exp_intop (bfd_vma value
)
191 etree_type
*new_e
= (etree_type
*) stat_alloc (sizeof (new_e
->value
));
192 new_e
->type
.node_code
= INT
;
193 new_e
->type
.filename
= ldlex_filename ();
194 new_e
->type
.lineno
= lineno
;
195 new_e
->value
.value
= value
;
196 new_e
->value
.str
= NULL
;
197 new_e
->type
.node_class
= etree_value
;
202 exp_bigintop (bfd_vma value
, char *str
)
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
= str
;
210 new_e
->type
.node_class
= etree_value
;
214 /* Build an expression representing an unnamed relocatable value. */
217 exp_relop (asection
*section
, bfd_vma value
)
219 etree_type
*new_e
= (etree_type
*) stat_alloc (sizeof (new_e
->rel
));
220 new_e
->type
.node_code
= REL
;
221 new_e
->type
.filename
= ldlex_filename ();
222 new_e
->type
.lineno
= lineno
;
223 new_e
->type
.node_class
= etree_rel
;
224 new_e
->rel
.section
= section
;
225 new_e
->rel
.value
= value
;
230 new_number (bfd_vma value
)
232 expld
.result
.valid_p
= TRUE
;
233 expld
.result
.value
= value
;
234 expld
.result
.str
= NULL
;
235 expld
.result
.section
= NULL
;
239 new_rel (bfd_vma value
, asection
*section
)
241 expld
.result
.valid_p
= TRUE
;
242 expld
.result
.value
= value
;
243 expld
.result
.str
= NULL
;
244 expld
.result
.section
= section
;
248 new_rel_from_abs (bfd_vma value
)
250 asection
*s
= expld
.section
;
252 if (s
== bfd_abs_section_ptr
&& expld
.phase
== lang_final_phase_enum
)
253 s
= section_for_dot ();
254 expld
.result
.valid_p
= TRUE
;
255 expld
.result
.value
= value
- s
->vma
;
256 expld
.result
.str
= NULL
;
257 expld
.result
.section
= s
;
260 /* New-function for the definedness hash table. */
262 static struct bfd_hash_entry
*
263 definedness_newfunc (struct bfd_hash_entry
*entry
,
264 struct bfd_hash_table
*table ATTRIBUTE_UNUSED
,
265 const char *name ATTRIBUTE_UNUSED
)
267 struct definedness_hash_entry
*ret
= (struct definedness_hash_entry
*) entry
;
270 ret
= (struct definedness_hash_entry
*)
271 bfd_hash_allocate (table
, sizeof (struct definedness_hash_entry
));
274 einfo (_("%P%F: bfd_hash_allocate failed creating symbol %s\n"), name
);
282 /* Called during processing of linker script script expressions.
283 For symbols assigned in a linker script, return a struct describing
284 where the symbol is defined relative to the current expression,
285 otherwise return NULL. */
287 static struct definedness_hash_entry
*
288 symbol_defined (const char *name
)
290 return ((struct definedness_hash_entry
*)
291 bfd_hash_lookup (&definedness_table
, name
, FALSE
, FALSE
));
294 /* Update the definedness state of NAME. Return FALSE if script symbol
295 is multiply defining a strong symbol in an object. */
298 update_definedness (const char *name
, struct bfd_link_hash_entry
*h
)
301 struct definedness_hash_entry
*defentry
302 = (struct definedness_hash_entry
*)
303 bfd_hash_lookup (&definedness_table
, name
, TRUE
, FALSE
);
305 if (defentry
== NULL
)
306 einfo (_("%P%F: bfd_hash_lookup failed creating symbol %s\n"), name
);
308 /* If the symbol was already defined, and not by a script, then it
309 must be defined by an object file or by the linker target code. */
311 if (!defentry
->by_script
312 && (h
->type
== bfd_link_hash_defined
313 || h
->type
== bfd_link_hash_defweak
314 || h
->type
== bfd_link_hash_common
))
316 defentry
->by_object
= 1;
317 if (h
->type
== bfd_link_hash_defined
318 && h
->u
.def
.section
->output_section
!= NULL
323 defentry
->by_script
= 1;
324 defentry
->iteration
= lang_statement_iteration
;
329 fold_unary (etree_type
*tree
)
331 exp_fold_tree_1 (tree
->unary
.child
);
332 if (expld
.result
.valid_p
)
334 switch (tree
->type
.node_code
)
337 if (expld
.phase
!= lang_first_phase_enum
)
338 new_rel_from_abs (align_n (expld
.dot
, expld
.result
.value
));
340 expld
.result
.valid_p
= FALSE
;
352 expld
.result
.value
= ~expld
.result
.value
;
356 expld
.result
.value
= !expld
.result
.value
;
360 expld
.result
.value
= -expld
.result
.value
;
364 /* Return next place aligned to value. */
365 if (expld
.phase
!= lang_first_phase_enum
)
368 expld
.result
.value
= align_n (expld
.dot
, expld
.result
.value
);
371 expld
.result
.valid_p
= FALSE
;
374 case DATA_SEGMENT_END
:
375 if (expld
.phase
== lang_first_phase_enum
376 || expld
.section
!= bfd_abs_section_ptr
)
378 expld
.result
.valid_p
= FALSE
;
380 else if (expld
.dataseg
.phase
== exp_dataseg_align_seen
381 || expld
.dataseg
.phase
== exp_dataseg_relro_seen
)
383 expld
.dataseg
.phase
= exp_dataseg_end_seen
;
384 expld
.dataseg
.end
= expld
.result
.value
;
386 else if (expld
.dataseg
.phase
== exp_dataseg_done
387 || expld
.dataseg
.phase
== exp_dataseg_adjust
388 || expld
.dataseg
.phase
== exp_dataseg_relro_adjust
)
393 expld
.result
.valid_p
= FALSE
;
404 fold_binary (etree_type
*tree
)
406 etree_value_type lhs
;
407 exp_fold_tree_1 (tree
->binary
.lhs
);
409 /* The SEGMENT_START operator is special because its first
410 operand is a string, not the name of a symbol. Note that the
411 operands have been swapped, so binary.lhs is second (default)
412 operand, binary.rhs is first operand. */
413 if (expld
.result
.valid_p
&& tree
->type
.node_code
== SEGMENT_START
)
415 const char *segment_name
;
418 /* Check to see if the user has overridden the default
420 segment_name
= tree
->binary
.rhs
->name
.name
;
421 for (seg
= segments
; seg
; seg
= seg
->next
)
422 if (strcmp (seg
->name
, segment_name
) == 0)
425 && config
.magic_demand_paged
426 && (seg
->value
% config
.maxpagesize
) != 0)
427 einfo (_("%P: warning: address of `%s' isn't multiple of maximum page size\n"),
430 new_rel_from_abs (seg
->value
);
437 exp_fold_tree_1 (tree
->binary
.rhs
);
438 expld
.result
.valid_p
&= lhs
.valid_p
;
440 if (expld
.result
.valid_p
)
442 if (lhs
.section
!= expld
.result
.section
)
444 /* If the values are from different sections, and neither is
445 just a number, make both the source arguments absolute. */
446 if (expld
.result
.section
!= NULL
447 && lhs
.section
!= NULL
)
450 lhs
.value
+= lhs
.section
->vma
;
451 lhs
.section
= bfd_abs_section_ptr
;
454 /* If the rhs is just a number, keep the lhs section. */
455 else if (expld
.result
.section
== NULL
)
457 expld
.result
.section
= lhs
.section
;
458 /* Make this NULL so that we know one of the operands
459 was just a number, for later tests. */
463 /* At this point we know that both operands have the same
464 section, or at least one of them is a plain number. */
466 switch (tree
->type
.node_code
)
468 /* Arithmetic operators, bitwise AND, bitwise OR and XOR
469 keep the section of one of their operands only when the
470 other operand is a plain number. Losing the section when
471 operating on two symbols, ie. a result of a plain number,
472 is required for subtraction and XOR. It's justifiable
473 for the other operations on the grounds that adding,
474 multiplying etc. two section relative values does not
475 really make sense unless they are just treated as
477 The same argument could be made for many expressions
478 involving one symbol and a number. For example,
479 "1 << x" and "100 / x" probably should not be given the
480 section of x. The trouble is that if we fuss about such
481 things the rules become complex and it is onerous to
482 document ld expression evaluation. */
485 expld.result.value = lhs.value y expld.result.value; \
486 if (expld.result.section == lhs.section) \
487 expld.result.section = NULL; \
490 /* Comparison operators, logical AND, and logical OR always
491 return a plain number. */
494 expld.result.value = lhs.value y expld.result.value; \
495 expld.result.section = NULL; \
516 if (expld
.result
.value
!= 0)
517 expld
.result
.value
= ((bfd_signed_vma
) lhs
.value
518 % (bfd_signed_vma
) expld
.result
.value
);
519 else if (expld
.phase
!= lang_mark_phase_enum
)
520 einfo (_("%F%S %% by zero\n"), tree
->binary
.rhs
);
521 if (expld
.result
.section
== lhs
.section
)
522 expld
.result
.section
= NULL
;
526 if (expld
.result
.value
!= 0)
527 expld
.result
.value
= ((bfd_signed_vma
) lhs
.value
528 / (bfd_signed_vma
) expld
.result
.value
);
529 else if (expld
.phase
!= lang_mark_phase_enum
)
530 einfo (_("%F%S / by zero\n"), tree
->binary
.rhs
);
531 if (expld
.result
.section
== lhs
.section
)
532 expld
.result
.section
= NULL
;
536 if (lhs
.value
> expld
.result
.value
)
537 expld
.result
.value
= lhs
.value
;
541 if (lhs
.value
< expld
.result
.value
)
542 expld
.result
.value
= lhs
.value
;
546 expld
.result
.value
= align_n (lhs
.value
, expld
.result
.value
);
549 case DATA_SEGMENT_ALIGN
:
550 expld
.dataseg
.relro
= exp_dataseg_relro_start
;
551 if (expld
.phase
== lang_first_phase_enum
552 || expld
.section
!= bfd_abs_section_ptr
)
553 expld
.result
.valid_p
= FALSE
;
556 bfd_vma maxpage
= lhs
.value
;
557 bfd_vma commonpage
= expld
.result
.value
;
559 expld
.result
.value
= align_n (expld
.dot
, maxpage
);
560 if (expld
.dataseg
.phase
== exp_dataseg_relro_adjust
)
561 expld
.result
.value
= expld
.dataseg
.base
;
562 else if (expld
.dataseg
.phase
== exp_dataseg_adjust
)
564 if (commonpage
< maxpage
)
565 expld
.result
.value
+= ((expld
.dot
+ commonpage
- 1)
566 & (maxpage
- commonpage
));
570 expld
.result
.value
+= expld
.dot
& (maxpage
- 1);
571 if (expld
.dataseg
.phase
== exp_dataseg_done
)
575 else if (expld
.dataseg
.phase
== exp_dataseg_none
)
577 expld
.dataseg
.phase
= exp_dataseg_align_seen
;
578 expld
.dataseg
.base
= expld
.result
.value
;
579 expld
.dataseg
.pagesize
= commonpage
;
580 expld
.dataseg
.maxpagesize
= maxpage
;
581 expld
.dataseg
.relro_end
= 0;
584 expld
.result
.valid_p
= FALSE
;
589 case DATA_SEGMENT_RELRO_END
:
590 /* Operands swapped! DATA_SEGMENT_RELRO_END(offset,exp)
591 has offset in expld.result and exp in lhs. */
592 expld
.dataseg
.relro
= exp_dataseg_relro_end
;
593 expld
.dataseg
.relro_offset
= expld
.result
.value
;
594 if (expld
.phase
== lang_first_phase_enum
595 || expld
.section
!= bfd_abs_section_ptr
)
596 expld
.result
.valid_p
= FALSE
;
597 else if (expld
.dataseg
.phase
== exp_dataseg_align_seen
598 || expld
.dataseg
.phase
== exp_dataseg_adjust
599 || expld
.dataseg
.phase
== exp_dataseg_relro_adjust
600 || expld
.dataseg
.phase
== exp_dataseg_done
)
602 if (expld
.dataseg
.phase
== exp_dataseg_align_seen
603 || expld
.dataseg
.phase
== exp_dataseg_relro_adjust
)
604 expld
.dataseg
.relro_end
= lhs
.value
+ expld
.result
.value
;
606 if (expld
.dataseg
.phase
== exp_dataseg_relro_adjust
607 && (expld
.dataseg
.relro_end
608 & (expld
.dataseg
.pagesize
- 1)))
610 expld
.dataseg
.relro_end
+= expld
.dataseg
.pagesize
- 1;
611 expld
.dataseg
.relro_end
&= ~(expld
.dataseg
.pagesize
- 1);
612 expld
.result
.value
= (expld
.dataseg
.relro_end
613 - expld
.result
.value
);
616 expld
.result
.value
= lhs
.value
;
618 if (expld
.dataseg
.phase
== exp_dataseg_align_seen
)
619 expld
.dataseg
.phase
= exp_dataseg_relro_seen
;
622 expld
.result
.valid_p
= FALSE
;
632 fold_trinary (etree_type
*tree
)
634 exp_fold_tree_1 (tree
->trinary
.cond
);
635 if (expld
.result
.valid_p
)
636 exp_fold_tree_1 (expld
.result
.value
638 : tree
->trinary
.rhs
);
642 fold_name (etree_type
*tree
)
644 memset (&expld
.result
, 0, sizeof (expld
.result
));
646 switch (tree
->type
.node_code
)
649 if (expld
.phase
!= lang_first_phase_enum
)
651 bfd_vma hdr_size
= 0;
652 /* Don't find the real header size if only marking sections;
653 The bfd function may cache incorrect data. */
654 if (expld
.phase
!= lang_mark_phase_enum
)
655 hdr_size
= bfd_sizeof_headers (link_info
.output_bfd
, &link_info
);
656 new_number (hdr_size
);
661 if (expld
.phase
!= lang_first_phase_enum
)
663 struct bfd_link_hash_entry
*h
;
664 struct definedness_hash_entry
*def
;
666 h
= bfd_wrapped_link_hash_lookup (link_info
.output_bfd
,
670 new_number (h
!= NULL
671 && (h
->type
== bfd_link_hash_defined
672 || h
->type
== bfd_link_hash_defweak
673 || h
->type
== bfd_link_hash_common
)
674 && ((def
= symbol_defined (tree
->name
.name
)) == NULL
676 || def
->iteration
== (lang_statement_iteration
& 1)));
681 if (expld
.assign_name
!= NULL
682 && strcmp (expld
.assign_name
, tree
->name
.name
) == 0)
684 /* Self-assignment is only allowed for absolute symbols
685 defined in a linker script. */
686 struct bfd_link_hash_entry
*h
;
687 struct definedness_hash_entry
*def
;
689 h
= bfd_wrapped_link_hash_lookup (link_info
.output_bfd
,
694 && (h
->type
== bfd_link_hash_defined
695 || h
->type
== bfd_link_hash_defweak
)
696 && h
->u
.def
.section
== bfd_abs_section_ptr
697 && (def
= symbol_defined (tree
->name
.name
)) != NULL
698 && def
->iteration
== (lang_statement_iteration
& 1)))
699 expld
.assign_name
= NULL
;
701 if (expld
.phase
== lang_first_phase_enum
)
703 else if (tree
->name
.name
[0] == '.' && tree
->name
.name
[1] == 0)
704 new_rel_from_abs (expld
.dot
);
707 struct bfd_link_hash_entry
*h
;
709 h
= bfd_wrapped_link_hash_lookup (link_info
.output_bfd
,
714 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
715 else if (h
->type
== bfd_link_hash_defined
716 || h
->type
== bfd_link_hash_defweak
)
718 asection
*output_section
;
720 output_section
= h
->u
.def
.section
->output_section
;
721 if (output_section
== NULL
)
723 if (expld
.phase
== lang_mark_phase_enum
)
724 new_rel (h
->u
.def
.value
, h
->u
.def
.section
);
726 einfo (_("%X%S: unresolvable symbol `%s'"
727 " referenced in expression\n"),
728 tree
, tree
->name
.name
);
730 else if (output_section
== bfd_abs_section_ptr
731 && (expld
.section
!= bfd_abs_section_ptr
732 || config
.sane_expr
))
733 new_number (h
->u
.def
.value
+ h
->u
.def
.section
->output_offset
);
735 new_rel (h
->u
.def
.value
+ h
->u
.def
.section
->output_offset
,
738 else if (expld
.phase
== lang_final_phase_enum
739 || (expld
.phase
!= lang_mark_phase_enum
740 && expld
.assigning_to_dot
))
741 einfo (_("%F%S: undefined symbol `%s'"
742 " referenced in expression\n"),
743 tree
, tree
->name
.name
);
744 else if (h
->type
== bfd_link_hash_new
)
746 h
->type
= bfd_link_hash_undefined
;
747 h
->u
.undef
.abfd
= NULL
;
748 if (h
->u
.undef
.next
== NULL
&& h
!= link_info
.hash
->undefs_tail
)
749 bfd_link_add_undef (link_info
.hash
, h
);
755 if (expld
.phase
!= lang_first_phase_enum
)
757 lang_output_section_statement_type
*os
;
759 os
= lang_output_section_find (tree
->name
.name
);
762 if (expld
.phase
== lang_final_phase_enum
)
763 einfo (_("%F%S: undefined section `%s'"
764 " referenced in expression\n"),
765 tree
, tree
->name
.name
);
767 else if (os
->processed_vma
)
768 new_rel (0, os
->bfd_section
);
773 if (expld
.phase
!= lang_first_phase_enum
)
775 lang_output_section_statement_type
*os
;
777 os
= lang_output_section_find (tree
->name
.name
);
780 if (expld
.phase
== lang_final_phase_enum
)
781 einfo (_("%F%S: undefined section `%s'"
782 " referenced in expression\n"),
783 tree
, tree
->name
.name
);
785 else if (os
->processed_lma
)
787 if (os
->load_base
== NULL
)
788 new_abs (os
->bfd_section
->lma
);
791 exp_fold_tree_1 (os
->load_base
);
792 if (expld
.result
.valid_p
)
801 if (expld
.phase
!= lang_first_phase_enum
)
803 lang_output_section_statement_type
*os
;
805 os
= lang_output_section_find (tree
->name
.name
);
808 if (expld
.phase
== lang_final_phase_enum
)
809 einfo (_("%F%S: undefined section `%s'"
810 " referenced in expression\n"),
811 tree
, tree
->name
.name
);
814 else if (os
->bfd_section
!= NULL
)
818 if (tree
->type
.node_code
== SIZEOF
)
819 val
= (os
->bfd_section
->size
820 / bfd_octets_per_byte (link_info
.output_bfd
));
822 val
= (bfd_vma
)1 << os
->bfd_section
->alignment_power
;
833 if (expld
.phase
!= lang_first_phase_enum
)
835 lang_memory_region_type
*mem
;
837 mem
= lang_memory_region_lookup (tree
->name
.name
, FALSE
);
839 new_number (mem
->length
);
841 einfo (_("%F%S: undefined MEMORY region `%s'"
842 " referenced in expression\n"),
843 tree
, tree
->name
.name
);
849 if (expld
.phase
!= lang_first_phase_enum
)
851 lang_memory_region_type
*mem
;
853 mem
= lang_memory_region_lookup (tree
->name
.name
, FALSE
);
855 new_rel_from_abs (mem
->origin
);
857 einfo (_("%F%S: undefined MEMORY region `%s'"
858 " referenced in expression\n"),
859 tree
, tree
->name
.name
);
864 if (strcmp (tree
->name
.name
, "MAXPAGESIZE") == 0)
865 new_number (config
.maxpagesize
);
866 else if (strcmp (tree
->name
.name
, "COMMONPAGESIZE") == 0)
867 new_number (config
.commonpagesize
);
869 einfo (_("%F%S: unknown constant `%s' referenced in expression\n"),
870 tree
, tree
->name
.name
);
879 /* Return true if TREE is '.'. */
882 is_dot (const etree_type
*tree
)
884 return (tree
->type
.node_class
== etree_name
885 && tree
->type
.node_code
== NAME
886 && tree
->name
.name
[0] == '.'
887 && tree
->name
.name
[1] == 0);
890 /* Return true if TREE is a constant equal to VAL. */
893 is_value (const etree_type
*tree
, bfd_vma val
)
895 return (tree
->type
.node_class
== etree_value
896 && tree
->value
.value
== val
);
899 /* Return true if TREE is an absolute symbol equal to VAL defined in
903 is_sym_value (const etree_type
*tree
, bfd_vma val
)
905 struct bfd_link_hash_entry
*h
;
906 struct definedness_hash_entry
*def
;
908 return (tree
->type
.node_class
== etree_name
909 && tree
->type
.node_code
== NAME
910 && (def
= symbol_defined (tree
->name
.name
)) != NULL
912 && def
->iteration
== (lang_statement_iteration
& 1)
913 && (h
= bfd_wrapped_link_hash_lookup (link_info
.output_bfd
,
916 FALSE
, FALSE
, TRUE
)) != NULL
917 && h
->type
== bfd_link_hash_defined
918 && h
->u
.def
.section
== bfd_abs_section_ptr
919 && h
->u
.def
.value
== val
);
922 /* Return true if TREE is ". != 0". */
925 is_dot_ne_0 (const etree_type
*tree
)
927 return (tree
->type
.node_class
== etree_binary
928 && tree
->type
.node_code
== NE
929 && is_dot (tree
->binary
.lhs
)
930 && is_value (tree
->binary
.rhs
, 0));
933 /* Return true if TREE is ". = . + 0" or ". = . + sym" where sym is an
934 absolute constant with value 0 defined in a linker script. */
937 is_dot_plus_0 (const etree_type
*tree
)
939 return (tree
->type
.node_class
== etree_binary
940 && tree
->type
.node_code
== '+'
941 && is_dot (tree
->binary
.lhs
)
942 && (is_value (tree
->binary
.rhs
, 0)
943 || is_sym_value (tree
->binary
.rhs
, 0)));
946 /* Return true if TREE is "ALIGN (. != 0 ? some_expression : 1)". */
949 is_align_conditional (const etree_type
*tree
)
951 if (tree
->type
.node_class
== etree_unary
952 && tree
->type
.node_code
== ALIGN_K
)
954 tree
= tree
->unary
.child
;
955 return (tree
->type
.node_class
== etree_trinary
956 && is_dot_ne_0 (tree
->trinary
.cond
)
957 && is_value (tree
->trinary
.rhs
, 1));
963 exp_fold_tree_1 (etree_type
*tree
)
967 memset (&expld
.result
, 0, sizeof (expld
.result
));
971 switch (tree
->type
.node_class
)
974 if (expld
.section
== bfd_abs_section_ptr
975 && !config
.sane_expr
)
976 new_abs (tree
->value
.value
);
978 new_number (tree
->value
.value
);
979 expld
.result
.str
= tree
->value
.str
;
983 if (expld
.phase
!= lang_first_phase_enum
)
985 asection
*output_section
= tree
->rel
.section
->output_section
;
986 new_rel (tree
->rel
.value
+ tree
->rel
.section
->output_offset
,
990 memset (&expld
.result
, 0, sizeof (expld
.result
));
994 exp_fold_tree_1 (tree
->assert_s
.child
);
995 if (expld
.phase
== lang_final_phase_enum
&& !expld
.result
.value
)
996 einfo ("%X%P: %s\n", tree
->assert_s
.message
);
1008 fold_trinary (tree
);
1013 case etree_provided
:
1014 if (tree
->assign
.dst
[0] == '.' && tree
->assign
.dst
[1] == 0)
1016 if (tree
->type
.node_class
!= etree_assign
)
1017 einfo (_("%F%S can not PROVIDE assignment to"
1018 " location counter\n"), tree
);
1019 if (expld
.phase
!= lang_first_phase_enum
)
1021 /* Notify the folder that this is an assignment to dot. */
1022 expld
.assigning_to_dot
= TRUE
;
1023 exp_fold_tree_1 (tree
->assign
.src
);
1024 expld
.assigning_to_dot
= FALSE
;
1026 /* If we are assigning to dot inside an output section
1027 arrange to keep the section, except for certain
1028 expressions that evaluate to zero. We ignore . = 0,
1029 . = . + 0, and . = ALIGN (. != 0 ? expr : 1). */
1030 if (expld
.phase
== lang_mark_phase_enum
1031 && expld
.section
!= bfd_abs_section_ptr
1032 && !(expld
.result
.valid_p
1033 && expld
.result
.value
== 0
1034 && (is_value (tree
->assign
.src
, 0)
1035 || is_sym_value (tree
->assign
.src
, 0)
1036 || is_dot_plus_0 (tree
->assign
.src
)
1037 || is_align_conditional (tree
->assign
.src
))))
1038 expld
.section
->flags
|= SEC_KEEP
;
1040 if (!expld
.result
.valid_p
)
1042 if (expld
.phase
!= lang_mark_phase_enum
)
1043 einfo (_("%F%S invalid assignment to"
1044 " location counter\n"), tree
);
1046 else if (expld
.dotp
== NULL
)
1047 einfo (_("%F%S assignment to location counter"
1048 " invalid outside of SECTIONS\n"), tree
);
1050 /* After allocation, assignment to dot should not be
1051 done inside an output section since allocation adds a
1052 padding statement that effectively duplicates the
1054 else if (expld
.phase
<= lang_allocating_phase_enum
1055 || expld
.section
== bfd_abs_section_ptr
)
1059 nextdot
= expld
.result
.value
;
1060 if (expld
.result
.section
!= NULL
)
1061 nextdot
+= expld
.result
.section
->vma
;
1063 nextdot
+= expld
.section
->vma
;
1064 if (nextdot
< expld
.dot
1065 && expld
.section
!= bfd_abs_section_ptr
)
1066 einfo (_("%F%S cannot move location counter backwards"
1067 " (from %V to %V)\n"),
1068 tree
, expld
.dot
, nextdot
);
1071 expld
.dot
= nextdot
;
1072 *expld
.dotp
= nextdot
;
1077 memset (&expld
.result
, 0, sizeof (expld
.result
));
1081 struct bfd_link_hash_entry
*h
= NULL
;
1083 if (tree
->type
.node_class
== etree_provide
)
1085 h
= bfd_link_hash_lookup (link_info
.hash
, tree
->assign
.dst
,
1086 FALSE
, FALSE
, TRUE
);
1088 || !(h
->type
== bfd_link_hash_new
1089 || h
->type
== bfd_link_hash_undefined
1092 /* Do nothing. The symbol was never referenced, or
1093 was defined in some object file. Undefined weak
1094 symbols stay undefined. */
1099 expld
.assign_name
= tree
->assign
.dst
;
1100 exp_fold_tree_1 (tree
->assign
.src
);
1101 /* expld.assign_name remaining equal to tree->assign.dst
1102 below indicates the evaluation of tree->assign.src did
1103 not use the value of tree->assign.dst. We don't allow
1104 self assignment until the final phase for two reasons:
1105 1) Expressions are evaluated multiple times. With
1106 relaxation, the number of times may vary.
1107 2) Section relative symbol values cannot be correctly
1108 converted to absolute values, as is required by many
1109 expressions, until final section sizing is complete. */
1110 if ((expld
.result
.valid_p
1111 && (expld
.phase
== lang_final_phase_enum
1112 || expld
.assign_name
!= NULL
))
1113 || (expld
.phase
<= lang_mark_phase_enum
1114 && tree
->type
.node_class
== etree_assign
1115 && tree
->assign
.defsym
))
1119 h
= bfd_link_hash_lookup (link_info
.hash
, tree
->assign
.dst
,
1122 einfo (_("%P%F:%s: hash creation failed\n"),
1126 if (expld
.result
.section
== NULL
)
1127 expld
.result
.section
= expld
.section
;
1128 if (!update_definedness (tree
->assign
.dst
, h
) && 0)
1130 /* Symbol was already defined. For now this error
1131 is disabled because it causes failures in the ld
1132 testsuite: ld-elf/var1, ld-scripts/defined5, and
1133 ld-scripts/pr14962. Some of these no doubt
1134 reflect scripts used in the wild. */
1135 (*link_info
.callbacks
->multiple_definition
)
1136 (&link_info
, h
, link_info
.output_bfd
,
1137 expld
.result
.section
, expld
.result
.value
);
1139 h
->type
= bfd_link_hash_defined
;
1140 h
->u
.def
.value
= expld
.result
.value
;
1141 h
->u
.def
.section
= expld
.result
.section
;
1142 if (tree
->type
.node_class
== etree_provide
)
1143 tree
->type
.node_class
= etree_provided
;
1145 /* Copy the symbol type if this is a simple assignment of
1146 one symbol to another. This could be more general
1147 (e.g. a ?: operator with NAMEs in each branch). */
1148 if (tree
->assign
.src
->type
.node_class
== etree_name
)
1150 struct bfd_link_hash_entry
*hsrc
;
1152 hsrc
= bfd_link_hash_lookup (link_info
.hash
,
1153 tree
->assign
.src
->name
.name
,
1154 FALSE
, FALSE
, TRUE
);
1156 bfd_copy_link_hash_symbol_type (link_info
.output_bfd
, h
,
1160 else if (expld
.phase
== lang_final_phase_enum
)
1162 h
= bfd_link_hash_lookup (link_info
.hash
, tree
->assign
.dst
,
1163 FALSE
, FALSE
, TRUE
);
1165 && h
->type
== bfd_link_hash_new
)
1166 h
->type
= bfd_link_hash_undefined
;
1168 expld
.assign_name
= NULL
;
1178 memset (&expld
.result
, 0, sizeof (expld
.result
));
1184 exp_fold_tree (etree_type
*tree
, asection
*current_section
, bfd_vma
*dotp
)
1188 expld
.section
= current_section
;
1189 exp_fold_tree_1 (tree
);
1193 exp_fold_tree_no_dot (etree_type
*tree
)
1197 expld
.section
= bfd_abs_section_ptr
;
1198 exp_fold_tree_1 (tree
);
1202 exp_binop (int code
, etree_type
*lhs
, etree_type
*rhs
)
1204 etree_type value
, *new_e
;
1206 value
.type
.node_code
= code
;
1207 value
.type
.filename
= lhs
->type
.filename
;
1208 value
.type
.lineno
= lhs
->type
.lineno
;
1209 value
.binary
.lhs
= lhs
;
1210 value
.binary
.rhs
= rhs
;
1211 value
.type
.node_class
= etree_binary
;
1212 exp_fold_tree_no_dot (&value
);
1213 if (expld
.result
.valid_p
)
1214 return exp_intop (expld
.result
.value
);
1216 new_e
= (etree_type
*) stat_alloc (sizeof (new_e
->binary
));
1217 memcpy (new_e
, &value
, sizeof (new_e
->binary
));
1222 exp_trinop (int code
, etree_type
*cond
, etree_type
*lhs
, etree_type
*rhs
)
1224 etree_type value
, *new_e
;
1226 value
.type
.node_code
= code
;
1227 value
.type
.filename
= cond
->type
.filename
;
1228 value
.type
.lineno
= cond
->type
.lineno
;
1229 value
.trinary
.lhs
= lhs
;
1230 value
.trinary
.cond
= cond
;
1231 value
.trinary
.rhs
= rhs
;
1232 value
.type
.node_class
= etree_trinary
;
1233 exp_fold_tree_no_dot (&value
);
1234 if (expld
.result
.valid_p
)
1235 return exp_intop (expld
.result
.value
);
1237 new_e
= (etree_type
*) stat_alloc (sizeof (new_e
->trinary
));
1238 memcpy (new_e
, &value
, sizeof (new_e
->trinary
));
1243 exp_unop (int code
, etree_type
*child
)
1245 etree_type value
, *new_e
;
1247 value
.unary
.type
.node_code
= code
;
1248 value
.unary
.type
.filename
= child
->type
.filename
;
1249 value
.unary
.type
.lineno
= child
->type
.lineno
;
1250 value
.unary
.child
= child
;
1251 value
.unary
.type
.node_class
= etree_unary
;
1252 exp_fold_tree_no_dot (&value
);
1253 if (expld
.result
.valid_p
)
1254 return exp_intop (expld
.result
.value
);
1256 new_e
= (etree_type
*) stat_alloc (sizeof (new_e
->unary
));
1257 memcpy (new_e
, &value
, sizeof (new_e
->unary
));
1262 exp_nameop (int code
, const char *name
)
1264 etree_type value
, *new_e
;
1266 value
.name
.type
.node_code
= code
;
1267 value
.name
.type
.filename
= ldlex_filename ();
1268 value
.name
.type
.lineno
= lineno
;
1269 value
.name
.name
= name
;
1270 value
.name
.type
.node_class
= etree_name
;
1272 exp_fold_tree_no_dot (&value
);
1273 if (expld
.result
.valid_p
)
1274 return exp_intop (expld
.result
.value
);
1276 new_e
= (etree_type
*) stat_alloc (sizeof (new_e
->name
));
1277 memcpy (new_e
, &value
, sizeof (new_e
->name
));
1283 exp_assop (const char *dst
,
1285 enum node_tree_enum
class,
1291 n
= (etree_type
*) stat_alloc (sizeof (n
->assign
));
1292 n
->assign
.type
.node_code
= '=';
1293 n
->assign
.type
.filename
= src
->type
.filename
;
1294 n
->assign
.type
.lineno
= src
->type
.lineno
;
1295 n
->assign
.type
.node_class
= class;
1296 n
->assign
.src
= src
;
1297 n
->assign
.dst
= dst
;
1298 n
->assign
.defsym
= defsym
;
1299 n
->assign
.hidden
= hidden
;
1303 /* Handle linker script assignments and HIDDEN. */
1306 exp_assign (const char *dst
, etree_type
*src
, bfd_boolean hidden
)
1308 return exp_assop (dst
, src
, etree_assign
, FALSE
, hidden
);
1311 /* Handle --defsym command-line option. */
1314 exp_defsym (const char *dst
, etree_type
*src
)
1316 return exp_assop (dst
, src
, etree_assign
, TRUE
, FALSE
);
1319 /* Handle PROVIDE. */
1322 exp_provide (const char *dst
, etree_type
*src
, bfd_boolean hidden
)
1324 return exp_assop (dst
, src
, etree_provide
, FALSE
, hidden
);
1327 /* Handle ASSERT. */
1330 exp_assert (etree_type
*exp
, const char *message
)
1334 n
= (etree_type
*) stat_alloc (sizeof (n
->assert_s
));
1335 n
->assert_s
.type
.node_code
= '!';
1336 n
->assert_s
.type
.filename
= exp
->type
.filename
;
1337 n
->assert_s
.type
.lineno
= exp
->type
.lineno
;
1338 n
->assert_s
.type
.node_class
= etree_assert
;
1339 n
->assert_s
.child
= exp
;
1340 n
->assert_s
.message
= message
;
1345 exp_print_tree (etree_type
*tree
)
1347 bfd_boolean function_like
;
1349 if (config
.map_file
== NULL
)
1350 config
.map_file
= stderr
;
1354 minfo ("NULL TREE\n");
1358 switch (tree
->type
.node_class
)
1361 minfo ("0x%v", tree
->value
.value
);
1364 if (tree
->rel
.section
->owner
!= NULL
)
1365 minfo ("%B:", tree
->rel
.section
->owner
);
1366 minfo ("%s+0x%v", tree
->rel
.section
->name
, tree
->rel
.value
);
1369 fputs (tree
->assign
.dst
, config
.map_file
);
1370 exp_print_token (tree
->type
.node_code
, TRUE
);
1371 exp_print_tree (tree
->assign
.src
);
1374 case etree_provided
:
1375 fprintf (config
.map_file
, "PROVIDE (%s, ", tree
->assign
.dst
);
1376 exp_print_tree (tree
->assign
.src
);
1377 fputc (')', config
.map_file
);
1380 function_like
= FALSE
;
1381 switch (tree
->type
.node_code
)
1386 case DATA_SEGMENT_ALIGN
:
1387 case DATA_SEGMENT_RELRO_END
:
1388 function_like
= TRUE
;
1391 /* Special handling because arguments are in reverse order and
1392 the segment name is quoted. */
1393 exp_print_token (tree
->type
.node_code
, FALSE
);
1394 fputs (" (\"", config
.map_file
);
1395 exp_print_tree (tree
->binary
.rhs
);
1396 fputs ("\", ", config
.map_file
);
1397 exp_print_tree (tree
->binary
.lhs
);
1398 fputc (')', config
.map_file
);
1403 exp_print_token (tree
->type
.node_code
, FALSE
);
1404 fputc (' ', config
.map_file
);
1406 fputc ('(', config
.map_file
);
1407 exp_print_tree (tree
->binary
.lhs
);
1409 fprintf (config
.map_file
, ", ");
1411 exp_print_token (tree
->type
.node_code
, TRUE
);
1412 exp_print_tree (tree
->binary
.rhs
);
1413 fputc (')', config
.map_file
);
1416 exp_print_tree (tree
->trinary
.cond
);
1417 fputc ('?', config
.map_file
);
1418 exp_print_tree (tree
->trinary
.lhs
);
1419 fputc (':', config
.map_file
);
1420 exp_print_tree (tree
->trinary
.rhs
);
1423 exp_print_token (tree
->unary
.type
.node_code
, FALSE
);
1424 if (tree
->unary
.child
)
1426 fprintf (config
.map_file
, " (");
1427 exp_print_tree (tree
->unary
.child
);
1428 fputc (')', config
.map_file
);
1433 fprintf (config
.map_file
, "ASSERT (");
1434 exp_print_tree (tree
->assert_s
.child
);
1435 fprintf (config
.map_file
, ", %s)", tree
->assert_s
.message
);
1439 if (tree
->type
.node_code
== NAME
)
1440 fputs (tree
->name
.name
, config
.map_file
);
1443 exp_print_token (tree
->type
.node_code
, FALSE
);
1444 if (tree
->name
.name
)
1445 fprintf (config
.map_file
, " (%s)", tree
->name
.name
);
1455 exp_get_vma (etree_type
*tree
, bfd_vma def
, char *name
)
1459 exp_fold_tree_no_dot (tree
);
1460 if (expld
.result
.valid_p
)
1461 return expld
.result
.value
;
1462 else if (name
!= NULL
&& expld
.phase
!= lang_mark_phase_enum
)
1463 einfo (_("%F%S: nonconstant expression for %s\n"),
1470 exp_get_value_int (etree_type
*tree
, int def
, char *name
)
1472 return exp_get_vma (tree
, def
, name
);
1476 exp_get_fill (etree_type
*tree
, fill_type
*def
, char *name
)
1485 exp_fold_tree_no_dot (tree
);
1486 if (!expld
.result
.valid_p
)
1488 if (name
!= NULL
&& expld
.phase
!= lang_mark_phase_enum
)
1489 einfo (_("%F%S: nonconstant expression for %s\n"),
1494 if (expld
.result
.str
!= NULL
&& (len
= strlen (expld
.result
.str
)) != 0)
1498 fill
= (fill_type
*) xmalloc ((len
+ 1) / 2 + sizeof (*fill
) - 1);
1499 fill
->size
= (len
+ 1) / 2;
1501 s
= (unsigned char *) expld
.result
.str
;
1509 digit
= (digit
- 'A' + '0' + 10) & 0xf;
1523 fill
= (fill_type
*) xmalloc (4 + sizeof (*fill
) - 1);
1524 val
= expld
.result
.value
;
1525 fill
->data
[0] = (val
>> 24) & 0xff;
1526 fill
->data
[1] = (val
>> 16) & 0xff;
1527 fill
->data
[2] = (val
>> 8) & 0xff;
1528 fill
->data
[3] = (val
>> 0) & 0xff;
1535 exp_get_abs_int (etree_type
*tree
, int def
, char *name
)
1539 exp_fold_tree_no_dot (tree
);
1541 if (expld
.result
.valid_p
)
1543 if (expld
.result
.section
!= NULL
)
1544 expld
.result
.value
+= expld
.result
.section
->vma
;
1545 return expld
.result
.value
;
1547 else if (name
!= NULL
&& expld
.phase
!= lang_mark_phase_enum
)
1549 einfo (_("%F%S: nonconstant expression for %s\n"),
1557 align_n (bfd_vma value
, bfd_vma align
)
1562 value
= (value
+ align
- 1) / align
;
1563 return value
* align
;
1569 /* The value "13" is ad-hoc, somewhat related to the expected number of
1570 assignments in a linker script. */
1571 if (!bfd_hash_table_init_n (&definedness_table
,
1572 definedness_newfunc
,
1573 sizeof (struct definedness_hash_entry
),
1575 einfo (_("%P%F: can not create hash table: %E\n"));
1581 bfd_hash_table_free (&definedness_table
);