1 /* This module handles expression trees.
2 Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
4 Free Software Foundation, Inc.
5 Written by Steve Chamberlain of Cygnus Support <sac@cygnus.com>.
7 This file is part of GLD, the Gnu Linker.
9 GLD 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 2, or (at your option)
14 GLD 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 GLD; see the file COPYING. If not, write to the Free
21 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
24 /* This module is in charge of working out the contents of expressions.
26 It has to keep track of the relative/absness of a symbol etc. This
27 is done by keeping all values in a struct (an etree_value_type)
28 which contains a value, a section to which it is relative and a
41 #include "libiberty.h"
42 #include "safe-ctype.h"
44 static etree_value_type exp_fold_tree_no_dot
45 (etree_type
*, lang_output_section_statement_type
*, lang_phase_type
);
46 static bfd_vma align_n
49 struct exp_data_seg exp_data_seg
;
51 segment_type
*segments
;
53 /* Print the string representation of the given token. Surround it
54 with spaces if INFIX_P is TRUE. */
57 exp_print_token (token_code_type code
, int infix_p
)
91 { SECTIONS
, "SECTIONS" },
92 { SIZEOF_HEADERS
, "SIZEOF_HEADERS" },
94 { DEFINED
, "DEFINED" },
95 { TARGET_K
, "TARGET" },
96 { SEARCH_DIR
, "SEARCH_DIR" },
100 { SIZEOF
, "SIZEOF" },
102 { LOADADDR
, "LOADADDR" },
104 { REL
, "relocatable" },
105 { DATA_SEGMENT_ALIGN
, "DATA_SEGMENT_ALIGN" },
106 { DATA_SEGMENT_RELRO_END
, "DATA_SEGMENT_RELRO_END" },
107 { DATA_SEGMENT_END
, "DATA_SEGMENT_END" },
108 { ORIGIN
, "ORIGIN" },
109 { LENGTH
, "LENGTH" },
110 { SEGMENT_START
, "SEGMENT_START" }
114 for (idx
= 0; idx
< ARRAY_SIZE (table
); idx
++)
115 if (table
[idx
].code
== code
)
119 fputc (' ', config
.map_file
);
121 if (idx
< ARRAY_SIZE (table
))
122 fputs (table
[idx
].name
, config
.map_file
);
124 fputc (code
, config
.map_file
);
126 fprintf (config
.map_file
, "<code %d>", code
);
129 fputc (' ', config
.map_file
);
133 make_abs (etree_value_type
*ptr
)
135 asection
*s
= ptr
->section
->bfd_section
;
136 ptr
->value
+= s
->vma
;
137 ptr
->section
= abs_output_section
;
140 static etree_value_type
141 new_abs (bfd_vma value
)
143 etree_value_type
new;
145 new.section
= abs_output_section
;
151 exp_intop (bfd_vma value
)
153 etree_type
*new = stat_alloc (sizeof (new->value
));
154 new->type
.node_code
= INT
;
155 new->value
.value
= value
;
156 new->value
.str
= NULL
;
157 new->type
.node_class
= etree_value
;
162 exp_bigintop (bfd_vma value
, char *str
)
164 etree_type
*new = stat_alloc (sizeof (new->value
));
165 new->type
.node_code
= INT
;
166 new->value
.value
= value
;
167 new->value
.str
= str
;
168 new->type
.node_class
= etree_value
;
172 /* Build an expression representing an unnamed relocatable value. */
175 exp_relop (asection
*section
, bfd_vma value
)
177 etree_type
*new = stat_alloc (sizeof (new->rel
));
178 new->type
.node_code
= REL
;
179 new->type
.node_class
= etree_rel
;
180 new->rel
.section
= section
;
181 new->rel
.value
= value
;
185 static etree_value_type
186 new_rel (bfd_vma value
,
188 lang_output_section_statement_type
*section
)
190 etree_value_type
new;
194 new.section
= section
;
198 static etree_value_type
199 new_rel_from_section (bfd_vma value
,
200 lang_output_section_statement_type
*section
)
202 etree_value_type
new;
206 new.section
= section
;
208 new.value
-= section
->bfd_section
->vma
;
213 static etree_value_type
214 fold_unary (etree_type
*tree
,
215 lang_output_section_statement_type
*current_section
,
216 lang_phase_type allocation_done
,
220 etree_value_type result
;
222 result
= exp_fold_tree (tree
->unary
.child
,
224 allocation_done
, dot
, dotp
);
227 switch (tree
->type
.node_code
)
230 if (allocation_done
!= lang_first_phase_enum
)
231 result
= new_rel_from_section (align_n (dot
, result
.value
),
234 result
.valid_p
= FALSE
;
238 if (allocation_done
!= lang_first_phase_enum
)
240 result
.value
+= result
.section
->bfd_section
->vma
;
241 result
.section
= abs_output_section
;
244 result
.valid_p
= FALSE
;
249 result
.value
= ~result
.value
;
254 result
.value
= !result
.value
;
259 result
.value
= -result
.value
;
263 /* Return next place aligned to value. */
264 if (allocation_done
== lang_allocating_phase_enum
)
267 result
.value
= align_n (dot
, result
.value
);
270 result
.valid_p
= FALSE
;
273 case DATA_SEGMENT_END
:
274 if (allocation_done
!= lang_first_phase_enum
275 && current_section
== abs_output_section
276 && (exp_data_seg
.phase
== exp_dataseg_align_seen
277 || exp_data_seg
.phase
== exp_dataseg_relro_seen
278 || exp_data_seg
.phase
== exp_dataseg_adjust
279 || exp_data_seg
.phase
== exp_dataseg_relro_adjust
280 || allocation_done
!= lang_allocating_phase_enum
))
282 if (exp_data_seg
.phase
== exp_dataseg_align_seen
283 || exp_data_seg
.phase
== exp_dataseg_relro_seen
)
285 exp_data_seg
.phase
= exp_dataseg_end_seen
;
286 exp_data_seg
.end
= result
.value
;
290 result
.valid_p
= FALSE
;
302 static etree_value_type
303 fold_binary (etree_type
*tree
,
304 lang_output_section_statement_type
*current_section
,
305 lang_phase_type allocation_done
,
309 etree_value_type result
;
311 result
= exp_fold_tree (tree
->binary
.lhs
, current_section
,
312 allocation_done
, dot
, dotp
);
314 /* The SEGMENT_START operator is special because its first
315 operand is a string, not the name of a symbol. */
316 if (result
.valid_p
&& tree
->type
.node_code
== SEGMENT_START
)
318 const char *segment_name
;
320 /* Check to see if the user has overridden the default
322 segment_name
= tree
->binary
.rhs
->name
.name
;
323 for (seg
= segments
; seg
; seg
= seg
->next
)
324 if (strcmp (seg
->name
, segment_name
) == 0)
327 result
.value
= seg
->value
;
329 result
.section
= NULL
;
333 else if (result
.valid_p
)
335 etree_value_type other
;
337 other
= exp_fold_tree (tree
->binary
.rhs
,
339 allocation_done
, dot
, dotp
);
342 /* If the values are from different sections, or this is an
343 absolute expression, make both the source arguments
344 absolute. However, adding or subtracting an absolute
345 value from a relative value is meaningful, and is an
347 if (current_section
!= abs_output_section
348 && (other
.section
== abs_output_section
349 || (result
.section
== abs_output_section
350 && tree
->type
.node_code
== '+'))
351 && (tree
->type
.node_code
== '+'
352 || tree
->type
.node_code
== '-'))
354 if (other
.section
!= abs_output_section
)
356 /* Keep the section of the other term. */
357 if (tree
->type
.node_code
== '+')
358 other
.value
= result
.value
+ other
.value
;
360 other
.value
= result
.value
- other
.value
;
364 else if (result
.section
!= other
.section
365 || current_section
== abs_output_section
)
371 switch (tree
->type
.node_code
)
374 if (other
.value
== 0)
375 einfo (_("%F%S %% by zero\n"));
376 result
.value
= ((bfd_signed_vma
) result
.value
377 % (bfd_signed_vma
) other
.value
);
381 if (other
.value
== 0)
382 einfo (_("%F%S / by zero\n"));
383 result
.value
= ((bfd_signed_vma
) result
.value
384 / (bfd_signed_vma
) other
.value
);
387 #define BOP(x,y) case x : result.value = result.value y other.value; break;
406 if (result
.value
< other
.value
)
411 if (result
.value
> other
.value
)
416 result
.value
= align_n (result
.value
, other
.value
);
419 case DATA_SEGMENT_ALIGN
:
420 if (allocation_done
!= lang_first_phase_enum
421 && current_section
== abs_output_section
422 && (exp_data_seg
.phase
== exp_dataseg_none
423 || exp_data_seg
.phase
== exp_dataseg_adjust
424 || exp_data_seg
.phase
== exp_dataseg_relro_adjust
425 || allocation_done
!= lang_allocating_phase_enum
))
427 bfd_vma maxpage
= result
.value
;
429 result
.value
= align_n (dot
, maxpage
);
430 if (exp_data_seg
.phase
== exp_dataseg_relro_adjust
)
431 result
.value
= exp_data_seg
.base
;
432 else if (exp_data_seg
.phase
!= exp_dataseg_adjust
)
434 result
.value
+= dot
& (maxpage
- 1);
435 if (allocation_done
== lang_allocating_phase_enum
)
437 exp_data_seg
.phase
= exp_dataseg_align_seen
;
438 exp_data_seg
.min_base
= align_n (dot
, maxpage
);
439 exp_data_seg
.base
= result
.value
;
440 exp_data_seg
.pagesize
= other
.value
;
441 exp_data_seg
.maxpagesize
= maxpage
;
442 exp_data_seg
.relro_end
= 0;
445 else if (other
.value
< maxpage
)
446 result
.value
+= (dot
+ other
.value
- 1)
447 & (maxpage
- other
.value
);
450 result
.valid_p
= FALSE
;
453 case DATA_SEGMENT_RELRO_END
:
454 if (allocation_done
!= lang_first_phase_enum
455 && (exp_data_seg
.phase
== exp_dataseg_align_seen
456 || exp_data_seg
.phase
== exp_dataseg_adjust
457 || exp_data_seg
.phase
== exp_dataseg_relro_adjust
458 || allocation_done
!= lang_allocating_phase_enum
))
460 if (exp_data_seg
.phase
== exp_dataseg_align_seen
461 || exp_data_seg
.phase
== exp_dataseg_relro_adjust
)
462 exp_data_seg
.relro_end
463 = result
.value
+ other
.value
;
464 if (exp_data_seg
.phase
== exp_dataseg_relro_adjust
465 && (exp_data_seg
.relro_end
466 & (exp_data_seg
.pagesize
- 1)))
468 exp_data_seg
.relro_end
+= exp_data_seg
.pagesize
- 1;
469 exp_data_seg
.relro_end
&= ~(exp_data_seg
.pagesize
- 1);
470 result
.value
= exp_data_seg
.relro_end
- other
.value
;
472 if (exp_data_seg
.phase
== exp_dataseg_align_seen
)
473 exp_data_seg
.phase
= exp_dataseg_relro_seen
;
476 result
.valid_p
= FALSE
;
485 result
.valid_p
= FALSE
;
492 static etree_value_type
493 fold_trinary (etree_type
*tree
,
494 lang_output_section_statement_type
*current_section
,
495 lang_phase_type allocation_done
,
499 etree_value_type result
;
501 result
= exp_fold_tree (tree
->trinary
.cond
, current_section
,
502 allocation_done
, dot
, dotp
);
504 result
= exp_fold_tree ((result
.value
506 : tree
->trinary
.rhs
),
508 allocation_done
, dot
, dotp
);
513 static etree_value_type
514 fold_name (etree_type
*tree
,
515 lang_output_section_statement_type
*current_section
,
516 lang_phase_type allocation_done
,
519 etree_value_type result
;
521 result
.valid_p
= FALSE
;
523 switch (tree
->type
.node_code
)
526 if (allocation_done
!= lang_first_phase_enum
)
527 result
= new_abs (bfd_sizeof_headers (output_bfd
,
528 link_info
.relocatable
));
531 if (allocation_done
== lang_first_phase_enum
)
532 lang_track_definedness (tree
->name
.name
);
535 struct bfd_link_hash_entry
*h
;
537 = lang_symbol_definition_iteration (tree
->name
.name
);
539 h
= bfd_wrapped_link_hash_lookup (output_bfd
, &link_info
,
542 result
.value
= (h
!= NULL
543 && (h
->type
== bfd_link_hash_defined
544 || h
->type
== bfd_link_hash_defweak
545 || h
->type
== bfd_link_hash_common
)
546 && (def_iteration
== lang_statement_iteration
547 || def_iteration
== -1));
548 result
.section
= abs_output_section
;
549 result
.valid_p
= TRUE
;
553 if (tree
->name
.name
[0] == '.' && tree
->name
.name
[1] == 0)
555 if (allocation_done
!= lang_first_phase_enum
)
556 result
= new_rel_from_section (dot
, current_section
);
558 else if (allocation_done
!= lang_first_phase_enum
)
560 struct bfd_link_hash_entry
*h
;
562 h
= bfd_wrapped_link_hash_lookup (output_bfd
, &link_info
,
566 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
567 else if (h
->type
== bfd_link_hash_defined
568 || h
->type
== bfd_link_hash_defweak
)
570 if (bfd_is_abs_section (h
->u
.def
.section
))
571 result
= new_abs (h
->u
.def
.value
);
572 else if (allocation_done
== lang_final_phase_enum
573 || allocation_done
== lang_allocating_phase_enum
)
575 asection
*output_section
;
577 output_section
= h
->u
.def
.section
->output_section
;
578 if (output_section
== NULL
)
579 einfo (_("%X%S: unresolvable symbol `%s' referenced in expression\n"),
583 lang_output_section_statement_type
*os
;
585 os
= (lang_output_section_statement_lookup
586 (bfd_get_section_name (output_bfd
,
589 /* FIXME: Is this correct if this section is
590 being linked with -R? */
591 result
= new_rel ((h
->u
.def
.value
592 + h
->u
.def
.section
->output_offset
),
598 else if (allocation_done
== lang_final_phase_enum
)
599 einfo (_("%F%S: undefined symbol `%s' referenced in expression\n"),
601 else if (h
->type
== bfd_link_hash_new
)
603 h
->type
= bfd_link_hash_undefined
;
604 h
->u
.undef
.abfd
= NULL
;
605 if (h
->u
.undef
.next
== NULL
&& h
!= link_info
.hash
->undefs_tail
)
606 bfd_link_add_undef (link_info
.hash
, h
);
612 if (allocation_done
!= lang_first_phase_enum
)
614 lang_output_section_statement_type
*os
;
616 os
= lang_output_section_find (tree
->name
.name
);
617 if (os
&& os
->processed
> 0)
618 result
= new_rel (0, NULL
, os
);
623 if (allocation_done
!= lang_first_phase_enum
)
625 lang_output_section_statement_type
*os
;
627 os
= lang_output_section_find (tree
->name
.name
);
628 if (os
&& os
->processed
!= 0)
630 if (os
->load_base
== NULL
)
631 result
= new_rel (0, NULL
, os
);
633 result
= exp_fold_tree_no_dot (os
->load_base
,
641 if (allocation_done
!= lang_first_phase_enum
)
643 int opb
= bfd_octets_per_byte (output_bfd
);
644 lang_output_section_statement_type
*os
;
646 os
= lang_output_section_find (tree
->name
.name
);
647 if (os
&& os
->processed
> 0)
648 result
= new_abs (os
->bfd_section
->size
/ opb
);
654 lang_memory_region_type
*mem
;
656 mem
= lang_memory_region_lookup (tree
->name
.name
, FALSE
);
658 result
= new_abs (mem
->length
);
660 einfo (_("%F%S: undefined MEMORY region `%s' referenced in expression\n"),
667 lang_memory_region_type
*mem
;
669 mem
= lang_memory_region_lookup (tree
->name
.name
, FALSE
);
671 result
= new_abs (mem
->origin
);
673 einfo (_("%F%S: undefined MEMORY region `%s' referenced in expression\n"),
687 exp_fold_tree (etree_type
*tree
,
688 lang_output_section_statement_type
*current_section
,
689 lang_phase_type allocation_done
,
693 etree_value_type result
;
697 result
.valid_p
= FALSE
;
701 switch (tree
->type
.node_class
)
704 result
= new_rel (tree
->value
.value
, tree
->value
.str
, current_section
);
708 if (allocation_done
!= lang_final_phase_enum
)
709 result
.valid_p
= FALSE
;
711 result
= new_rel ((tree
->rel
.value
712 + tree
->rel
.section
->output_section
->vma
713 + tree
->rel
.section
->output_offset
),
719 result
= exp_fold_tree (tree
->assert_s
.child
,
721 allocation_done
, dot
, dotp
);
725 einfo ("%X%P: %s\n", tree
->assert_s
.message
);
731 result
= fold_unary (tree
, current_section
, allocation_done
,
736 result
= fold_binary (tree
, current_section
, allocation_done
,
741 result
= fold_trinary (tree
, current_section
, allocation_done
,
748 if (tree
->assign
.dst
[0] == '.' && tree
->assign
.dst
[1] == 0)
750 /* Assignment to dot can only be done during allocation. */
751 if (tree
->type
.node_class
!= etree_assign
)
752 einfo (_("%F%S can not PROVIDE assignment to location counter\n"));
753 if (allocation_done
== lang_allocating_phase_enum
754 || (allocation_done
== lang_final_phase_enum
755 && current_section
== abs_output_section
))
757 result
= exp_fold_tree (tree
->assign
.src
,
759 allocation_done
, dot
,
761 if (! result
.valid_p
)
762 einfo (_("%F%S invalid assignment to location counter\n"));
765 if (current_section
== NULL
)
766 einfo (_("%F%S assignment to location counter invalid outside of SECTION\n"));
771 nextdot
= (result
.value
772 + current_section
->bfd_section
->vma
);
774 && current_section
!= abs_output_section
)
775 einfo (_("%F%S cannot move location counter backwards (from %V to %V)\n"),
785 result
= exp_fold_tree (tree
->assign
.src
,
786 current_section
, allocation_done
,
791 struct bfd_link_hash_entry
*h
;
793 if (tree
->type
.node_class
== etree_assign
)
797 h
= bfd_link_hash_lookup (link_info
.hash
, tree
->assign
.dst
,
798 create
, FALSE
, TRUE
);
802 einfo (_("%P%F:%s: hash creation failed\n"),
805 else if (tree
->type
.node_class
== etree_provide
806 && h
->type
!= bfd_link_hash_new
807 && h
->type
!= bfd_link_hash_undefined
808 && h
->type
!= bfd_link_hash_common
)
810 /* Do nothing. The symbol was defined by some
815 /* FIXME: Should we worry if the symbol is already
817 lang_update_definedness (tree
->assign
.dst
, h
);
818 h
->type
= bfd_link_hash_defined
;
819 h
->u
.def
.value
= result
.value
;
820 h
->u
.def
.section
= result
.section
->bfd_section
;
821 if (tree
->type
.node_class
== etree_provide
)
822 tree
->type
.node_class
= etree_provided
;
829 result
= fold_name (tree
, current_section
, allocation_done
, dot
);
840 static etree_value_type
841 exp_fold_tree_no_dot (etree_type
*tree
,
842 lang_output_section_statement_type
*current_section
,
843 lang_phase_type allocation_done
)
845 return exp_fold_tree (tree
, current_section
, allocation_done
, 0, NULL
);
849 exp_binop (int code
, etree_type
*lhs
, etree_type
*rhs
)
851 etree_type value
, *new;
854 value
.type
.node_code
= code
;
855 value
.binary
.lhs
= lhs
;
856 value
.binary
.rhs
= rhs
;
857 value
.type
.node_class
= etree_binary
;
858 r
= exp_fold_tree_no_dot (&value
,
860 lang_first_phase_enum
);
863 return exp_intop (r
.value
);
865 new = stat_alloc (sizeof (new->binary
));
866 memcpy (new, &value
, sizeof (new->binary
));
871 exp_trinop (int code
, etree_type
*cond
, etree_type
*lhs
, etree_type
*rhs
)
873 etree_type value
, *new;
875 value
.type
.node_code
= code
;
876 value
.trinary
.lhs
= lhs
;
877 value
.trinary
.cond
= cond
;
878 value
.trinary
.rhs
= rhs
;
879 value
.type
.node_class
= etree_trinary
;
880 r
= exp_fold_tree_no_dot (&value
, NULL
, lang_first_phase_enum
);
882 return exp_intop (r
.value
);
884 new = stat_alloc (sizeof (new->trinary
));
885 memcpy (new, &value
, sizeof (new->trinary
));
890 exp_unop (int code
, etree_type
*child
)
892 etree_type value
, *new;
895 value
.unary
.type
.node_code
= code
;
896 value
.unary
.child
= child
;
897 value
.unary
.type
.node_class
= etree_unary
;
898 r
= exp_fold_tree_no_dot (&value
, abs_output_section
,
899 lang_first_phase_enum
);
901 return exp_intop (r
.value
);
903 new = stat_alloc (sizeof (new->unary
));
904 memcpy (new, &value
, sizeof (new->unary
));
909 exp_nameop (int code
, const char *name
)
911 etree_type value
, *new;
913 value
.name
.type
.node_code
= code
;
914 value
.name
.name
= name
;
915 value
.name
.type
.node_class
= etree_name
;
917 r
= exp_fold_tree_no_dot (&value
, NULL
, lang_first_phase_enum
);
919 return exp_intop (r
.value
);
921 new = stat_alloc (sizeof (new->name
));
922 memcpy (new, &value
, sizeof (new->name
));
928 exp_assop (int code
, const char *dst
, etree_type
*src
)
930 etree_type value
, *new;
932 value
.assign
.type
.node_code
= code
;
934 value
.assign
.src
= src
;
935 value
.assign
.dst
= dst
;
936 value
.assign
.type
.node_class
= etree_assign
;
939 if (exp_fold_tree_no_dot (&value
, &result
))
940 return exp_intop (result
);
942 new = stat_alloc (sizeof (new->assign
));
943 memcpy (new, &value
, sizeof (new->assign
));
947 /* Handle PROVIDE. */
950 exp_provide (const char *dst
, etree_type
*src
)
954 n
= stat_alloc (sizeof (n
->assign
));
955 n
->assign
.type
.node_code
= '=';
956 n
->assign
.type
.node_class
= etree_provide
;
965 exp_assert (etree_type
*exp
, const char *message
)
969 n
= stat_alloc (sizeof (n
->assert_s
));
970 n
->assert_s
.type
.node_code
= '!';
971 n
->assert_s
.type
.node_class
= etree_assert
;
972 n
->assert_s
.child
= exp
;
973 n
->assert_s
.message
= message
;
978 exp_print_tree (etree_type
*tree
)
980 if (config
.map_file
== NULL
)
981 config
.map_file
= stderr
;
985 minfo ("NULL TREE\n");
989 switch (tree
->type
.node_class
)
992 minfo ("0x%v", tree
->value
.value
);
995 if (tree
->rel
.section
->owner
!= NULL
)
996 minfo ("%B:", tree
->rel
.section
->owner
);
997 minfo ("%s+0x%v", tree
->rel
.section
->name
, tree
->rel
.value
);
1001 if (tree
->assign
.dst
->sdefs
!= NULL
)
1002 fprintf (config
.map_file
, "%s (%x) ", tree
->assign
.dst
->name
,
1003 tree
->assign
.dst
->sdefs
->value
);
1005 fprintf (config
.map_file
, "%s (UNDEFINED)", tree
->assign
.dst
->name
);
1007 fprintf (config
.map_file
, "%s", tree
->assign
.dst
);
1008 exp_print_token (tree
->type
.node_code
, TRUE
);
1009 exp_print_tree (tree
->assign
.src
);
1012 case etree_provided
:
1013 fprintf (config
.map_file
, "PROVIDE (%s, ", tree
->assign
.dst
);
1014 exp_print_tree (tree
->assign
.src
);
1015 fprintf (config
.map_file
, ")");
1018 fprintf (config
.map_file
, "(");
1019 exp_print_tree (tree
->binary
.lhs
);
1020 exp_print_token (tree
->type
.node_code
, TRUE
);
1021 exp_print_tree (tree
->binary
.rhs
);
1022 fprintf (config
.map_file
, ")");
1025 exp_print_tree (tree
->trinary
.cond
);
1026 fprintf (config
.map_file
, "?");
1027 exp_print_tree (tree
->trinary
.lhs
);
1028 fprintf (config
.map_file
, ":");
1029 exp_print_tree (tree
->trinary
.rhs
);
1032 exp_print_token (tree
->unary
.type
.node_code
, FALSE
);
1033 if (tree
->unary
.child
)
1035 fprintf (config
.map_file
, " (");
1036 exp_print_tree (tree
->unary
.child
);
1037 fprintf (config
.map_file
, ")");
1042 fprintf (config
.map_file
, "ASSERT (");
1043 exp_print_tree (tree
->assert_s
.child
);
1044 fprintf (config
.map_file
, ", %s)", tree
->assert_s
.message
);
1048 fprintf (config
.map_file
, "????????");
1051 if (tree
->type
.node_code
== NAME
)
1053 fprintf (config
.map_file
, "%s", tree
->name
.name
);
1057 exp_print_token (tree
->type
.node_code
, FALSE
);
1058 if (tree
->name
.name
)
1059 fprintf (config
.map_file
, " (%s)", tree
->name
.name
);
1069 exp_get_vma (etree_type
*tree
,
1072 lang_phase_type allocation_done
)
1078 r
= exp_fold_tree_no_dot (tree
, abs_output_section
, allocation_done
);
1079 if (! r
.valid_p
&& name
!= NULL
)
1080 einfo (_("%F%S nonconstant expression for %s\n"), name
);
1088 exp_get_value_int (etree_type
*tree
,
1091 lang_phase_type allocation_done
)
1093 return exp_get_vma (tree
, def
, name
, allocation_done
);
1097 exp_get_fill (etree_type
*tree
,
1100 lang_phase_type allocation_done
)
1110 r
= exp_fold_tree_no_dot (tree
, abs_output_section
, allocation_done
);
1111 if (! r
.valid_p
&& name
!= NULL
)
1112 einfo (_("%F%S nonconstant expression for %s\n"), name
);
1114 if (r
.str
!= NULL
&& (len
= strlen (r
.str
)) != 0)
1118 fill
= xmalloc ((len
+ 1) / 2 + sizeof (*fill
) - 1);
1119 fill
->size
= (len
+ 1) / 2;
1129 digit
= (digit
- 'A' + '0' + 10) & 0xf;
1143 fill
= xmalloc (4 + sizeof (*fill
) - 1);
1145 fill
->data
[0] = (val
>> 24) & 0xff;
1146 fill
->data
[1] = (val
>> 16) & 0xff;
1147 fill
->data
[2] = (val
>> 8) & 0xff;
1148 fill
->data
[3] = (val
>> 0) & 0xff;
1155 exp_get_abs_int (etree_type
*tree
,
1156 int def ATTRIBUTE_UNUSED
,
1158 lang_phase_type allocation_done
)
1160 etree_value_type res
;
1161 res
= exp_fold_tree_no_dot (tree
, abs_output_section
, allocation_done
);
1164 res
.value
+= res
.section
->bfd_section
->vma
;
1166 einfo (_("%F%S non constant expression for %s\n"), name
);
1172 align_n (bfd_vma value
, bfd_vma align
)
1177 value
= (value
+ align
- 1) / align
;
1178 return value
* align
;