1 /* This module handles expression trees.
2 Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008
4 Free Software Foundation, Inc.
5 Written by Steve Chamberlain of Cygnus Support <sac@cygnus.com>.
7 This file is part of the GNU Binutils.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
22 MA 02110-1301, USA. */
25 /* This module is in charge of working out the contents of expressions.
27 It has to keep track of the relative/absness of a symbol etc. This
28 is done by keeping all values in a struct (an etree_value_type)
29 which contains a value, a section to which it is relative and a
43 #include "libiberty.h"
44 #include "safe-ctype.h"
46 static void exp_fold_tree_1 (etree_type
*);
47 static void exp_fold_tree_no_dot (etree_type
*);
48 static bfd_vma
align_n (bfd_vma
, bfd_vma
);
50 segment_type
*segments
;
52 struct ldexp_control expld
;
54 /* Print the string representation of the given token. Surround it
55 with spaces if INFIX_P is TRUE. */
58 exp_print_token (token_code_type code
, int infix_p
)
92 { SECTIONS
, "SECTIONS" },
93 { SIZEOF_HEADERS
, "SIZEOF_HEADERS" },
95 { DEFINED
, "DEFINED" },
96 { TARGET_K
, "TARGET" },
97 { SEARCH_DIR
, "SEARCH_DIR" },
101 { ALIGNOF
, "ALIGNOF" },
102 { SIZEOF
, "SIZEOF" },
104 { LOADADDR
, "LOADADDR" },
105 { CONSTANT
, "CONSTANT" },
106 { ABSOLUTE
, "ABSOLUTE" },
109 { ASSERT_K
, "ASSERT" },
110 { REL
, "relocatable" },
111 { DATA_SEGMENT_ALIGN
, "DATA_SEGMENT_ALIGN" },
112 { DATA_SEGMENT_RELRO_END
, "DATA_SEGMENT_RELRO_END" },
113 { DATA_SEGMENT_END
, "DATA_SEGMENT_END" },
114 { ORIGIN
, "ORIGIN" },
115 { LENGTH
, "LENGTH" },
116 { SEGMENT_START
, "SEGMENT_START" }
120 for (idx
= 0; idx
< ARRAY_SIZE (table
); idx
++)
121 if (table
[idx
].code
== code
)
125 fputc (' ', config
.map_file
);
127 if (idx
< ARRAY_SIZE (table
))
128 fputs (table
[idx
].name
, config
.map_file
);
130 fputc (code
, config
.map_file
);
132 fprintf (config
.map_file
, "<code %d>", code
);
135 fputc (' ', config
.map_file
);
141 expld
.result
.value
+= expld
.result
.section
->vma
;
142 expld
.result
.section
= bfd_abs_section_ptr
;
146 new_abs (bfd_vma value
)
148 expld
.result
.valid_p
= TRUE
;
149 expld
.result
.section
= bfd_abs_section_ptr
;
150 expld
.result
.value
= value
;
151 expld
.result
.str
= NULL
;
155 exp_intop (bfd_vma value
)
157 etree_type
*new = stat_alloc (sizeof (new->value
));
158 new->type
.node_code
= INT
;
159 new->type
.lineno
= lineno
;
160 new->value
.value
= value
;
161 new->value
.str
= NULL
;
162 new->type
.node_class
= etree_value
;
167 exp_bigintop (bfd_vma value
, char *str
)
169 etree_type
*new = stat_alloc (sizeof (new->value
));
170 new->type
.node_code
= INT
;
171 new->type
.lineno
= lineno
;
172 new->value
.value
= value
;
173 new->value
.str
= str
;
174 new->type
.node_class
= etree_value
;
178 /* Build an expression representing an unnamed relocatable value. */
181 exp_relop (asection
*section
, bfd_vma value
)
183 etree_type
*new = stat_alloc (sizeof (new->rel
));
184 new->type
.node_code
= REL
;
185 new->type
.lineno
= lineno
;
186 new->type
.node_class
= etree_rel
;
187 new->rel
.section
= section
;
188 new->rel
.value
= value
;
193 new_rel (bfd_vma value
, char *str
, asection
*section
)
195 expld
.result
.valid_p
= TRUE
;
196 expld
.result
.value
= value
;
197 expld
.result
.str
= str
;
198 expld
.result
.section
= section
;
202 new_rel_from_abs (bfd_vma value
)
204 expld
.result
.valid_p
= TRUE
;
205 expld
.result
.value
= value
- expld
.section
->vma
;
206 expld
.result
.str
= NULL
;
207 expld
.result
.section
= expld
.section
;
211 fold_unary (etree_type
*tree
)
213 exp_fold_tree_1 (tree
->unary
.child
);
214 if (expld
.result
.valid_p
)
216 switch (tree
->type
.node_code
)
219 if (expld
.phase
!= lang_first_phase_enum
)
220 new_rel_from_abs (align_n (expld
.dot
, expld
.result
.value
));
222 expld
.result
.valid_p
= FALSE
;
231 expld
.result
.value
= ~expld
.result
.value
;
236 expld
.result
.value
= !expld
.result
.value
;
241 expld
.result
.value
= -expld
.result
.value
;
245 /* Return next place aligned to value. */
246 if (expld
.phase
!= lang_first_phase_enum
)
249 expld
.result
.value
= align_n (expld
.dot
, expld
.result
.value
);
252 expld
.result
.valid_p
= FALSE
;
255 case DATA_SEGMENT_END
:
256 if (expld
.phase
!= lang_first_phase_enum
257 && expld
.section
== bfd_abs_section_ptr
258 && (expld
.dataseg
.phase
== exp_dataseg_align_seen
259 || expld
.dataseg
.phase
== exp_dataseg_relro_seen
260 || expld
.dataseg
.phase
== exp_dataseg_adjust
261 || expld
.dataseg
.phase
== exp_dataseg_relro_adjust
262 || expld
.phase
== lang_final_phase_enum
))
264 if (expld
.dataseg
.phase
== exp_dataseg_align_seen
265 || expld
.dataseg
.phase
== exp_dataseg_relro_seen
)
267 expld
.dataseg
.phase
= exp_dataseg_end_seen
;
268 expld
.dataseg
.end
= expld
.result
.value
;
272 expld
.result
.valid_p
= FALSE
;
283 fold_binary (etree_type
*tree
)
285 exp_fold_tree_1 (tree
->binary
.lhs
);
287 /* The SEGMENT_START operator is special because its first
288 operand is a string, not the name of a symbol. Note that the
289 operands have been swapped, so binary.lhs is second (default)
290 operand, binary.rhs is first operand. */
291 if (expld
.result
.valid_p
&& tree
->type
.node_code
== SEGMENT_START
)
293 const char *segment_name
;
295 /* Check to see if the user has overridden the default
297 segment_name
= tree
->binary
.rhs
->name
.name
;
298 for (seg
= segments
; seg
; seg
= seg
->next
)
299 if (strcmp (seg
->name
, segment_name
) == 0)
302 expld
.result
.value
= seg
->value
;
303 expld
.result
.str
= NULL
;
304 expld
.result
.section
= expld
.section
;
308 else if (expld
.result
.valid_p
)
310 etree_value_type lhs
= expld
.result
;
312 exp_fold_tree_1 (tree
->binary
.rhs
);
313 if (expld
.result
.valid_p
)
315 /* If the values are from different sections, or this is an
316 absolute expression, make both the source arguments
317 absolute. However, adding or subtracting an absolute
318 value from a relative value is meaningful, and is an
320 if (expld
.section
!= bfd_abs_section_ptr
321 && lhs
.section
== bfd_abs_section_ptr
322 && tree
->type
.node_code
== '+')
324 /* Keep the section of the rhs term. */
325 expld
.result
.value
= lhs
.value
+ expld
.result
.value
;
328 else if (expld
.section
!= bfd_abs_section_ptr
329 && expld
.result
.section
== bfd_abs_section_ptr
330 && (tree
->type
.node_code
== '+'
331 || tree
->type
.node_code
== '-'))
333 /* Keep the section of the lhs term. */
334 expld
.result
.section
= lhs
.section
;
336 else if (expld
.result
.section
!= lhs
.section
337 || expld
.section
== bfd_abs_section_ptr
)
340 lhs
.value
+= lhs
.section
->vma
;
343 switch (tree
->type
.node_code
)
346 if (expld
.result
.value
!= 0)
347 expld
.result
.value
= ((bfd_signed_vma
) lhs
.value
348 % (bfd_signed_vma
) expld
.result
.value
);
349 else if (expld
.phase
!= lang_mark_phase_enum
)
350 einfo (_("%F%S %% by zero\n"));
354 if (expld
.result
.value
!= 0)
355 expld
.result
.value
= ((bfd_signed_vma
) lhs
.value
356 / (bfd_signed_vma
) expld
.result
.value
);
357 else if (expld
.phase
!= lang_mark_phase_enum
)
358 einfo (_("%F%S / by zero\n"));
363 expld.result.value = lhs.value y expld.result.value; \
384 if (lhs
.value
> expld
.result
.value
)
385 expld
.result
.value
= lhs
.value
;
389 if (lhs
.value
< expld
.result
.value
)
390 expld
.result
.value
= lhs
.value
;
394 expld
.result
.value
= align_n (lhs
.value
, expld
.result
.value
);
397 case DATA_SEGMENT_ALIGN
:
398 expld
.dataseg
.relro
= exp_dataseg_relro_start
;
399 if (expld
.phase
!= lang_first_phase_enum
400 && expld
.section
== bfd_abs_section_ptr
401 && (expld
.dataseg
.phase
== exp_dataseg_none
402 || expld
.dataseg
.phase
== exp_dataseg_adjust
403 || expld
.dataseg
.phase
== exp_dataseg_relro_adjust
404 || expld
.phase
== lang_final_phase_enum
))
406 bfd_vma maxpage
= lhs
.value
;
407 bfd_vma commonpage
= expld
.result
.value
;
409 expld
.result
.value
= align_n (expld
.dot
, maxpage
);
410 if (expld
.dataseg
.phase
== exp_dataseg_relro_adjust
)
411 expld
.result
.value
= expld
.dataseg
.base
;
412 else if (expld
.dataseg
.phase
!= exp_dataseg_adjust
)
414 expld
.result
.value
+= expld
.dot
& (maxpage
- 1);
415 if (expld
.phase
== lang_allocating_phase_enum
)
417 expld
.dataseg
.phase
= exp_dataseg_align_seen
;
418 expld
.dataseg
.min_base
= align_n (expld
.dot
, maxpage
);
419 expld
.dataseg
.base
= expld
.result
.value
;
420 expld
.dataseg
.pagesize
= commonpage
;
421 expld
.dataseg
.maxpagesize
= maxpage
;
422 expld
.dataseg
.relro_end
= 0;
425 else if (commonpage
< maxpage
)
426 expld
.result
.value
+= ((expld
.dot
+ commonpage
- 1)
427 & (maxpage
- commonpage
));
430 expld
.result
.valid_p
= FALSE
;
433 case DATA_SEGMENT_RELRO_END
:
434 expld
.dataseg
.relro
= exp_dataseg_relro_end
;
435 if (expld
.phase
!= lang_first_phase_enum
436 && (expld
.dataseg
.phase
== exp_dataseg_align_seen
437 || expld
.dataseg
.phase
== exp_dataseg_adjust
438 || expld
.dataseg
.phase
== exp_dataseg_relro_adjust
439 || expld
.phase
== lang_final_phase_enum
))
441 if (expld
.dataseg
.phase
== exp_dataseg_align_seen
442 || expld
.dataseg
.phase
== exp_dataseg_relro_adjust
)
443 expld
.dataseg
.relro_end
= lhs
.value
+ expld
.result
.value
;
445 if (expld
.dataseg
.phase
== exp_dataseg_relro_adjust
446 && (expld
.dataseg
.relro_end
447 & (expld
.dataseg
.pagesize
- 1)))
449 expld
.dataseg
.relro_end
+= expld
.dataseg
.pagesize
- 1;
450 expld
.dataseg
.relro_end
&= ~(expld
.dataseg
.pagesize
- 1);
451 expld
.result
.value
= (expld
.dataseg
.relro_end
452 - expld
.result
.value
);
455 expld
.result
.value
= lhs
.value
;
457 if (expld
.dataseg
.phase
== exp_dataseg_align_seen
)
458 expld
.dataseg
.phase
= exp_dataseg_relro_seen
;
461 expld
.result
.valid_p
= FALSE
;
469 expld
.result
.valid_p
= FALSE
;
474 fold_trinary (etree_type
*tree
)
476 exp_fold_tree_1 (tree
->trinary
.cond
);
477 if (expld
.result
.valid_p
)
478 exp_fold_tree_1 (expld
.result
.value
480 : tree
->trinary
.rhs
);
484 fold_name (etree_type
*tree
)
486 memset (&expld
.result
, 0, sizeof (expld
.result
));
488 switch (tree
->type
.node_code
)
491 if (expld
.phase
!= lang_first_phase_enum
)
493 bfd_vma hdr_size
= 0;
494 /* Don't find the real header size if only marking sections;
495 The bfd function may cache incorrect data. */
496 if (expld
.phase
!= lang_mark_phase_enum
)
497 hdr_size
= bfd_sizeof_headers (link_info
.output_bfd
, &link_info
);
503 if (expld
.phase
== lang_first_phase_enum
)
504 lang_track_definedness (tree
->name
.name
);
507 struct bfd_link_hash_entry
*h
;
509 = lang_symbol_definition_iteration (tree
->name
.name
);
511 h
= bfd_wrapped_link_hash_lookup (link_info
.output_bfd
,
515 expld
.result
.value
= (h
!= NULL
516 && (h
->type
== bfd_link_hash_defined
517 || h
->type
== bfd_link_hash_defweak
518 || h
->type
== bfd_link_hash_common
)
519 && (def_iteration
== lang_statement_iteration
520 || def_iteration
== -1));
521 expld
.result
.section
= expld
.section
;
522 expld
.result
.valid_p
= TRUE
;
527 if (expld
.phase
== lang_first_phase_enum
)
529 else if (tree
->name
.name
[0] == '.' && tree
->name
.name
[1] == 0)
530 new_rel_from_abs (expld
.dot
);
533 struct bfd_link_hash_entry
*h
;
535 h
= bfd_wrapped_link_hash_lookup (link_info
.output_bfd
,
540 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
541 else if (h
->type
== bfd_link_hash_defined
542 || h
->type
== bfd_link_hash_defweak
)
544 if (bfd_is_abs_section (h
->u
.def
.section
))
545 new_abs (h
->u
.def
.value
);
548 asection
*output_section
;
550 output_section
= h
->u
.def
.section
->output_section
;
551 if (output_section
== NULL
)
553 if (expld
.phase
!= lang_mark_phase_enum
)
554 einfo (_("%X%S: unresolvable symbol `%s'"
555 " referenced in expression\n"),
559 new_rel (h
->u
.def
.value
+ h
->u
.def
.section
->output_offset
,
560 NULL
, output_section
);
563 else if (expld
.phase
== lang_final_phase_enum
564 || expld
.assigning_to_dot
)
565 einfo (_("%F%S: undefined symbol `%s' referenced in expression\n"),
567 else if (h
->type
== bfd_link_hash_new
)
569 h
->type
= bfd_link_hash_undefined
;
570 h
->u
.undef
.abfd
= NULL
;
571 if (h
->u
.undef
.next
== NULL
&& h
!= link_info
.hash
->undefs_tail
)
572 bfd_link_add_undef (link_info
.hash
, h
);
578 if (expld
.phase
!= lang_first_phase_enum
)
580 lang_output_section_statement_type
*os
;
582 os
= lang_output_section_find (tree
->name
.name
);
585 if (expld
.phase
== lang_final_phase_enum
)
586 einfo (_("%F%S: undefined section `%s' referenced in expression\n"),
589 else if (os
->processed_vma
)
590 new_rel (0, NULL
, os
->bfd_section
);
595 if (expld
.phase
!= lang_first_phase_enum
)
597 lang_output_section_statement_type
*os
;
599 os
= lang_output_section_find (tree
->name
.name
);
602 if (expld
.phase
== lang_final_phase_enum
)
603 einfo (_("%F%S: undefined section `%s' referenced in expression\n"),
606 else if (os
->processed_lma
)
608 if (os
->load_base
== NULL
)
609 new_abs (os
->bfd_section
->lma
);
612 exp_fold_tree_1 (os
->load_base
);
613 if (expld
.result
.valid_p
)
622 if (expld
.phase
!= lang_first_phase_enum
)
624 lang_output_section_statement_type
*os
;
626 os
= lang_output_section_find (tree
->name
.name
);
629 if (expld
.phase
== lang_final_phase_enum
)
630 einfo (_("%F%S: undefined section `%s' referenced in expression\n"),
634 else if (os
->processed_vma
)
638 if (tree
->type
.node_code
== SIZEOF
)
639 val
= (os
->bfd_section
->size
640 / bfd_octets_per_byte (link_info
.output_bfd
));
642 val
= (bfd_vma
)1 << os
->bfd_section
->alignment_power
;
651 lang_memory_region_type
*mem
;
653 mem
= lang_memory_region_lookup (tree
->name
.name
, FALSE
);
655 new_abs (mem
->length
);
657 einfo (_("%F%S: undefined MEMORY region `%s'"
658 " referenced in expression\n"), tree
->name
.name
);
664 lang_memory_region_type
*mem
;
666 mem
= lang_memory_region_lookup (tree
->name
.name
, FALSE
);
668 new_abs (mem
->origin
);
670 einfo (_("%F%S: undefined MEMORY region `%s'"
671 " referenced in expression\n"), tree
->name
.name
);
676 if (strcmp (tree
->name
.name
, "MAXPAGESIZE") == 0)
677 new_abs (bfd_emul_get_maxpagesize (default_target
));
678 else if (strcmp (tree
->name
.name
, "COMMONPAGESIZE") == 0)
679 new_abs (bfd_emul_get_commonpagesize (default_target
));
681 einfo (_("%F%S: unknown constant `%s' referenced in expression\n"),
692 exp_fold_tree_1 (etree_type
*tree
)
696 memset (&expld
.result
, 0, sizeof (expld
.result
));
700 switch (tree
->type
.node_class
)
703 new_rel (tree
->value
.value
, tree
->value
.str
, expld
.section
);
707 if (expld
.phase
!= lang_first_phase_enum
)
709 asection
*output_section
= tree
->rel
.section
->output_section
;
710 new_rel (tree
->rel
.value
+ tree
->rel
.section
->output_offset
,
711 NULL
, output_section
);
714 memset (&expld
.result
, 0, sizeof (expld
.result
));
718 exp_fold_tree_1 (tree
->assert_s
.child
);
719 if (expld
.phase
== lang_final_phase_enum
&& !expld
.result
.value
)
720 einfo ("%X%P: %s\n", tree
->assert_s
.message
);
738 if (tree
->assign
.dst
[0] == '.' && tree
->assign
.dst
[1] == 0)
740 /* Assignment to dot can only be done during allocation. */
741 if (tree
->type
.node_class
!= etree_assign
)
742 einfo (_("%F%S can not PROVIDE assignment to location counter\n"));
743 if (expld
.phase
== lang_mark_phase_enum
744 || expld
.phase
== lang_allocating_phase_enum
745 || (expld
.phase
== lang_final_phase_enum
746 && expld
.section
== bfd_abs_section_ptr
))
748 /* Notify the folder that this is an assignment to dot. */
749 expld
.assigning_to_dot
= TRUE
;
750 exp_fold_tree_1 (tree
->assign
.src
);
751 expld
.assigning_to_dot
= FALSE
;
753 if (!expld
.result
.valid_p
)
755 if (expld
.phase
!= lang_mark_phase_enum
)
756 einfo (_("%F%S invalid assignment to location counter\n"));
758 else if (expld
.dotp
== NULL
)
759 einfo (_("%F%S assignment to location counter"
760 " invalid outside of SECTION\n"));
765 nextdot
= expld
.result
.value
+ expld
.section
->vma
;
766 if (nextdot
< expld
.dot
767 && expld
.section
!= bfd_abs_section_ptr
)
768 einfo (_("%F%S cannot move location counter backwards"
769 " (from %V to %V)\n"), expld
.dot
, nextdot
);
773 *expld
.dotp
= nextdot
;
778 memset (&expld
.result
, 0, sizeof (expld
.result
));
782 struct bfd_link_hash_entry
*h
= NULL
;
784 if (tree
->type
.node_class
== etree_provide
)
786 h
= bfd_link_hash_lookup (link_info
.hash
, tree
->assign
.dst
,
789 || (h
->type
!= bfd_link_hash_new
790 && h
->type
!= bfd_link_hash_undefined
791 && h
->type
!= bfd_link_hash_common
))
793 /* Do nothing. The symbol was never referenced, or was
794 defined by some object. */
799 exp_fold_tree_1 (tree
->assign
.src
);
800 if (expld
.result
.valid_p
)
804 h
= bfd_link_hash_lookup (link_info
.hash
, tree
->assign
.dst
,
807 einfo (_("%P%F:%s: hash creation failed\n"),
811 /* FIXME: Should we worry if the symbol is already
813 lang_update_definedness (tree
->assign
.dst
, h
);
814 h
->type
= bfd_link_hash_defined
;
815 h
->u
.def
.value
= expld
.result
.value
;
816 h
->u
.def
.section
= expld
.result
.section
;
817 if (tree
->type
.node_class
== etree_provide
)
818 tree
->type
.node_class
= etree_provided
;
829 memset (&expld
.result
, 0, sizeof (expld
.result
));
835 exp_fold_tree (etree_type
*tree
, asection
*current_section
, bfd_vma
*dotp
)
839 expld
.section
= current_section
;
840 exp_fold_tree_1 (tree
);
844 exp_fold_tree_no_dot (etree_type
*tree
)
848 expld
.section
= bfd_abs_section_ptr
;
849 exp_fold_tree_1 (tree
);
853 exp_binop (int code
, etree_type
*lhs
, etree_type
*rhs
)
855 etree_type value
, *new;
857 value
.type
.node_code
= code
;
858 value
.type
.lineno
= lhs
->type
.lineno
;
859 value
.binary
.lhs
= lhs
;
860 value
.binary
.rhs
= rhs
;
861 value
.type
.node_class
= etree_binary
;
862 exp_fold_tree_no_dot (&value
);
863 if (expld
.result
.valid_p
)
864 return exp_intop (expld
.result
.value
);
866 new = stat_alloc (sizeof (new->binary
));
867 memcpy (new, &value
, sizeof (new->binary
));
872 exp_trinop (int code
, etree_type
*cond
, etree_type
*lhs
, etree_type
*rhs
)
874 etree_type value
, *new;
876 value
.type
.node_code
= code
;
877 value
.type
.lineno
= lhs
->type
.lineno
;
878 value
.trinary
.lhs
= lhs
;
879 value
.trinary
.cond
= cond
;
880 value
.trinary
.rhs
= rhs
;
881 value
.type
.node_class
= etree_trinary
;
882 exp_fold_tree_no_dot (&value
);
883 if (expld
.result
.valid_p
)
884 return exp_intop (expld
.result
.value
);
886 new = stat_alloc (sizeof (new->trinary
));
887 memcpy (new, &value
, sizeof (new->trinary
));
892 exp_unop (int code
, etree_type
*child
)
894 etree_type value
, *new;
896 value
.unary
.type
.node_code
= code
;
897 value
.unary
.type
.lineno
= child
->type
.lineno
;
898 value
.unary
.child
= child
;
899 value
.unary
.type
.node_class
= etree_unary
;
900 exp_fold_tree_no_dot (&value
);
901 if (expld
.result
.valid_p
)
902 return exp_intop (expld
.result
.value
);
904 new = stat_alloc (sizeof (new->unary
));
905 memcpy (new, &value
, sizeof (new->unary
));
910 exp_nameop (int code
, const char *name
)
912 etree_type value
, *new;
914 value
.name
.type
.node_code
= code
;
915 value
.name
.type
.lineno
= lineno
;
916 value
.name
.name
= name
;
917 value
.name
.type
.node_class
= etree_name
;
919 exp_fold_tree_no_dot (&value
);
920 if (expld
.result
.valid_p
)
921 return exp_intop (expld
.result
.value
);
923 new = stat_alloc (sizeof (new->name
));
924 memcpy (new, &value
, sizeof (new->name
));
930 exp_assop (int code
, const char *dst
, etree_type
*src
)
934 new = stat_alloc (sizeof (new->assign
));
935 new->type
.node_code
= code
;
936 new->type
.lineno
= src
->type
.lineno
;
937 new->type
.node_class
= etree_assign
;
938 new->assign
.src
= src
;
939 new->assign
.dst
= dst
;
943 /* Handle PROVIDE. */
946 exp_provide (const char *dst
, etree_type
*src
, bfd_boolean hidden
)
950 n
= stat_alloc (sizeof (n
->assign
));
951 n
->assign
.type
.node_code
= '=';
952 n
->assign
.type
.lineno
= src
->type
.lineno
;
953 n
->assign
.type
.node_class
= etree_provide
;
956 n
->assign
.hidden
= hidden
;
963 exp_assert (etree_type
*exp
, const char *message
)
967 n
= stat_alloc (sizeof (n
->assert_s
));
968 n
->assert_s
.type
.node_code
= '!';
969 n
->assert_s
.type
.lineno
= exp
->type
.lineno
;
970 n
->assert_s
.type
.node_class
= etree_assert
;
971 n
->assert_s
.child
= exp
;
972 n
->assert_s
.message
= message
;
977 exp_print_tree (etree_type
*tree
)
979 if (config
.map_file
== NULL
)
980 config
.map_file
= stderr
;
984 minfo ("NULL TREE\n");
988 switch (tree
->type
.node_class
)
991 minfo ("0x%v", tree
->value
.value
);
994 if (tree
->rel
.section
->owner
!= NULL
)
995 minfo ("%B:", tree
->rel
.section
->owner
);
996 minfo ("%s+0x%v", tree
->rel
.section
->name
, tree
->rel
.value
);
999 fprintf (config
.map_file
, "%s", tree
->assign
.dst
);
1000 exp_print_token (tree
->type
.node_code
, TRUE
);
1001 exp_print_tree (tree
->assign
.src
);
1004 case etree_provided
:
1005 fprintf (config
.map_file
, "PROVIDE (%s, ", tree
->assign
.dst
);
1006 exp_print_tree (tree
->assign
.src
);
1007 fprintf (config
.map_file
, ")");
1010 fprintf (config
.map_file
, "(");
1011 exp_print_tree (tree
->binary
.lhs
);
1012 exp_print_token (tree
->type
.node_code
, TRUE
);
1013 exp_print_tree (tree
->binary
.rhs
);
1014 fprintf (config
.map_file
, ")");
1017 exp_print_tree (tree
->trinary
.cond
);
1018 fprintf (config
.map_file
, "?");
1019 exp_print_tree (tree
->trinary
.lhs
);
1020 fprintf (config
.map_file
, ":");
1021 exp_print_tree (tree
->trinary
.rhs
);
1024 exp_print_token (tree
->unary
.type
.node_code
, FALSE
);
1025 if (tree
->unary
.child
)
1027 fprintf (config
.map_file
, " (");
1028 exp_print_tree (tree
->unary
.child
);
1029 fprintf (config
.map_file
, ")");
1034 fprintf (config
.map_file
, "ASSERT (");
1035 exp_print_tree (tree
->assert_s
.child
);
1036 fprintf (config
.map_file
, ", %s)", tree
->assert_s
.message
);
1040 if (tree
->type
.node_code
== NAME
)
1042 fprintf (config
.map_file
, "%s", tree
->name
.name
);
1046 exp_print_token (tree
->type
.node_code
, FALSE
);
1047 if (tree
->name
.name
)
1048 fprintf (config
.map_file
, " (%s)", tree
->name
.name
);
1058 exp_get_vma (etree_type
*tree
, bfd_vma def
, char *name
)
1062 exp_fold_tree_no_dot (tree
);
1063 if (expld
.result
.valid_p
)
1064 return expld
.result
.value
;
1065 else if (name
!= NULL
&& expld
.phase
!= lang_mark_phase_enum
)
1066 einfo (_("%F%S: nonconstant expression for %s\n"), name
);
1072 exp_get_value_int (etree_type
*tree
, int def
, char *name
)
1074 return exp_get_vma (tree
, def
, name
);
1078 exp_get_fill (etree_type
*tree
, fill_type
*def
, char *name
)
1087 exp_fold_tree_no_dot (tree
);
1088 if (!expld
.result
.valid_p
)
1090 if (name
!= NULL
&& expld
.phase
!= lang_mark_phase_enum
)
1091 einfo (_("%F%S: nonconstant expression for %s\n"), name
);
1095 if (expld
.result
.str
!= NULL
&& (len
= strlen (expld
.result
.str
)) != 0)
1099 fill
= xmalloc ((len
+ 1) / 2 + sizeof (*fill
) - 1);
1100 fill
->size
= (len
+ 1) / 2;
1102 s
= (unsigned char *) expld
.result
.str
;
1110 digit
= (digit
- 'A' + '0' + 10) & 0xf;
1124 fill
= xmalloc (4 + sizeof (*fill
) - 1);
1125 val
= expld
.result
.value
;
1126 fill
->data
[0] = (val
>> 24) & 0xff;
1127 fill
->data
[1] = (val
>> 16) & 0xff;
1128 fill
->data
[2] = (val
>> 8) & 0xff;
1129 fill
->data
[3] = (val
>> 0) & 0xff;
1136 exp_get_abs_int (etree_type
*tree
, int def
, char *name
)
1140 exp_fold_tree_no_dot (tree
);
1142 if (expld
.result
.valid_p
)
1144 expld
.result
.value
+= expld
.result
.section
->vma
;
1145 return expld
.result
.value
;
1147 else if (name
!= NULL
&& expld
.phase
!= lang_mark_phase_enum
)
1149 lineno
= tree
->type
.lineno
;
1150 einfo (_("%F%S: nonconstant expression for %s\n"), name
);
1157 align_n (bfd_vma value
, bfd_vma align
)
1162 value
= (value
+ align
- 1) / align
;
1163 return value
* align
;