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 /* Print the string representation of the given token. Surround it
52 with spaces if INFIX_P is TRUE. */
55 exp_print_token (token_code_type code
, int infix_p
)
89 { SECTIONS
, "SECTIONS" },
90 { SIZEOF_HEADERS
, "SIZEOF_HEADERS" },
92 { DEFINED
, "DEFINED" },
93 { TARGET_K
, "TARGET" },
94 { SEARCH_DIR
, "SEARCH_DIR" },
100 { LOADADDR
, "LOADADDR" },
102 { REL
, "relocatable" },
103 { DATA_SEGMENT_ALIGN
, "DATA_SEGMENT_ALIGN" },
104 { DATA_SEGMENT_RELRO_END
, "DATA_SEGMENT_RELRO_END" },
105 { DATA_SEGMENT_END
, "DATA_SEGMENT_END" }
109 for (idx
= 0; idx
< ARRAY_SIZE (table
); idx
++)
110 if (table
[idx
].code
== code
)
114 fputc (' ', config
.map_file
);
116 if (idx
< ARRAY_SIZE (table
))
117 fputs (table
[idx
].name
, config
.map_file
);
119 fputc (code
, config
.map_file
);
121 fprintf (config
.map_file
, "<code %d>", code
);
124 fputc (' ', config
.map_file
);
128 make_abs (etree_value_type
*ptr
)
130 asection
*s
= ptr
->section
->bfd_section
;
131 ptr
->value
+= s
->vma
;
132 ptr
->section
= abs_output_section
;
135 static etree_value_type
136 new_abs (bfd_vma value
)
138 etree_value_type
new;
140 new.section
= abs_output_section
;
146 exp_intop (bfd_vma value
)
148 etree_type
*new = stat_alloc (sizeof (new->value
));
149 new->type
.node_code
= INT
;
150 new->value
.value
= value
;
151 new->value
.str
= NULL
;
152 new->type
.node_class
= etree_value
;
157 exp_bigintop (bfd_vma value
, char *str
)
159 etree_type
*new = stat_alloc (sizeof (new->value
));
160 new->type
.node_code
= INT
;
161 new->value
.value
= value
;
162 new->value
.str
= str
;
163 new->type
.node_class
= etree_value
;
167 /* Build an expression representing an unnamed relocatable value. */
170 exp_relop (asection
*section
, bfd_vma value
)
172 etree_type
*new = stat_alloc (sizeof (new->rel
));
173 new->type
.node_code
= REL
;
174 new->type
.node_class
= etree_rel
;
175 new->rel
.section
= section
;
176 new->rel
.value
= value
;
180 static etree_value_type
181 new_rel (bfd_vma value
,
183 lang_output_section_statement_type
*section
)
185 etree_value_type
new;
189 new.section
= section
;
193 static etree_value_type
194 new_rel_from_section (bfd_vma value
,
195 lang_output_section_statement_type
*section
)
197 etree_value_type
new;
201 new.section
= section
;
203 new.value
-= section
->bfd_section
->vma
;
208 static etree_value_type
209 fold_unary (etree_type
*tree
,
210 lang_output_section_statement_type
*current_section
,
211 lang_phase_type allocation_done
,
215 etree_value_type result
;
217 result
= exp_fold_tree (tree
->unary
.child
,
219 allocation_done
, dot
, dotp
);
222 switch (tree
->type
.node_code
)
225 if (allocation_done
!= lang_first_phase_enum
)
226 result
= new_rel_from_section (align_n (dot
, result
.value
),
229 result
.valid_p
= FALSE
;
233 if (allocation_done
!= lang_first_phase_enum
)
235 result
.value
+= result
.section
->bfd_section
->vma
;
236 result
.section
= abs_output_section
;
239 result
.valid_p
= FALSE
;
244 result
.value
= ~result
.value
;
249 result
.value
= !result
.value
;
254 result
.value
= -result
.value
;
258 /* Return next place aligned to value. */
259 if (allocation_done
== lang_allocating_phase_enum
)
262 result
.value
= align_n (dot
, result
.value
);
265 result
.valid_p
= FALSE
;
268 case DATA_SEGMENT_RELRO_END
:
269 if (allocation_done
!= lang_first_phase_enum
270 && (exp_data_seg
.phase
== exp_dataseg_align_seen
271 || exp_data_seg
.phase
== exp_dataseg_adjust
272 || exp_data_seg
.phase
== exp_dataseg_relro_adjust
273 || allocation_done
!= lang_allocating_phase_enum
))
275 if (exp_data_seg
.phase
== exp_dataseg_align_seen
276 || exp_data_seg
.phase
== exp_dataseg_relro_adjust
)
277 exp_data_seg
.relro_end
278 = result
.value
+ current_section
->bfd_section
->vma
;
279 if (exp_data_seg
.phase
== exp_dataseg_align_seen
)
280 exp_data_seg
.phase
= exp_dataseg_relro_seen
;
281 result
.value
= dot
- current_section
->bfd_section
->vma
;
284 result
.valid_p
= FALSE
;
287 case DATA_SEGMENT_END
:
288 if (allocation_done
!= lang_first_phase_enum
289 && current_section
== abs_output_section
290 && (exp_data_seg
.phase
== exp_dataseg_align_seen
291 || exp_data_seg
.phase
== exp_dataseg_relro_seen
292 || exp_data_seg
.phase
== exp_dataseg_adjust
293 || exp_data_seg
.phase
== exp_dataseg_relro_adjust
294 || allocation_done
!= lang_allocating_phase_enum
))
296 if (exp_data_seg
.phase
== exp_dataseg_align_seen
297 || exp_data_seg
.phase
== exp_dataseg_relro_seen
)
299 exp_data_seg
.phase
= exp_dataseg_end_seen
;
300 exp_data_seg
.end
= result
.value
;
304 result
.valid_p
= FALSE
;
316 static etree_value_type
317 fold_binary (etree_type
*tree
,
318 lang_output_section_statement_type
*current_section
,
319 lang_phase_type allocation_done
,
323 etree_value_type result
;
325 result
= exp_fold_tree (tree
->binary
.lhs
, current_section
,
326 allocation_done
, dot
, dotp
);
329 etree_value_type other
;
331 other
= exp_fold_tree (tree
->binary
.rhs
,
333 allocation_done
, dot
, dotp
);
336 /* If the values are from different sections, or this is an
337 absolute expression, make both the source arguments
338 absolute. However, adding or subtracting an absolute
339 value from a relative value is meaningful, and is an
341 if (current_section
!= abs_output_section
342 && (other
.section
== abs_output_section
343 || (result
.section
== abs_output_section
344 && tree
->type
.node_code
== '+'))
345 && (tree
->type
.node_code
== '+'
346 || tree
->type
.node_code
== '-'))
348 if (other
.section
!= abs_output_section
)
350 /* Keep the section of the other term. */
351 if (tree
->type
.node_code
== '+')
352 other
.value
= result
.value
+ other
.value
;
354 other
.value
= result
.value
- other
.value
;
358 else if (result
.section
!= other
.section
359 || current_section
== abs_output_section
)
365 switch (tree
->type
.node_code
)
368 if (other
.value
== 0)
369 einfo (_("%F%S %% by zero\n"));
370 result
.value
= ((bfd_signed_vma
) result
.value
371 % (bfd_signed_vma
) other
.value
);
375 if (other
.value
== 0)
376 einfo (_("%F%S / by zero\n"));
377 result
.value
= ((bfd_signed_vma
) result
.value
378 / (bfd_signed_vma
) other
.value
);
381 #define BOP(x,y) case x : result.value = result.value y other.value; break;
400 if (result
.value
< other
.value
)
405 if (result
.value
> other
.value
)
410 result
.value
= align_n (result
.value
, other
.value
);
413 case DATA_SEGMENT_ALIGN
:
414 if (allocation_done
!= lang_first_phase_enum
415 && current_section
== abs_output_section
416 && (exp_data_seg
.phase
== exp_dataseg_none
417 || exp_data_seg
.phase
== exp_dataseg_adjust
418 || exp_data_seg
.phase
== exp_dataseg_relro_adjust
419 || allocation_done
!= lang_allocating_phase_enum
))
421 bfd_vma maxpage
= result
.value
;
423 result
.value
= align_n (dot
, maxpage
);
424 if (exp_data_seg
.phase
== exp_dataseg_relro_adjust
)
426 /* Attempt to align DATA_SEGMENT_RELRO_END at
427 a common page boundary. */
430 relro
= exp_data_seg
.relro_end
- exp_data_seg
.base
;
431 result
.value
+= -relro
& (other
.value
- 1);
432 exp_data_seg
.base
= result
.value
;
434 else if (exp_data_seg
.phase
!= exp_dataseg_adjust
)
436 result
.value
+= dot
& (maxpage
- 1);
437 if (allocation_done
== lang_allocating_phase_enum
)
439 exp_data_seg
.phase
= exp_dataseg_align_seen
;
440 exp_data_seg
.base
= result
.value
;
441 exp_data_seg
.pagesize
= other
.value
;
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
;
459 result
.valid_p
= FALSE
;
466 static etree_value_type
467 fold_trinary (etree_type
*tree
,
468 lang_output_section_statement_type
*current_section
,
469 lang_phase_type allocation_done
,
473 etree_value_type result
;
475 result
= exp_fold_tree (tree
->trinary
.cond
, current_section
,
476 allocation_done
, dot
, dotp
);
478 result
= exp_fold_tree ((result
.value
480 : tree
->trinary
.rhs
),
482 allocation_done
, dot
, dotp
);
487 static etree_value_type
488 fold_name (etree_type
*tree
,
489 lang_output_section_statement_type
*current_section
,
490 lang_phase_type allocation_done
,
493 etree_value_type result
;
495 result
.valid_p
= FALSE
;
497 switch (tree
->type
.node_code
)
500 if (allocation_done
!= lang_first_phase_enum
)
501 result
= new_abs (bfd_sizeof_headers (output_bfd
,
502 link_info
.relocatable
));
505 if (allocation_done
== lang_first_phase_enum
)
506 lang_track_definedness (tree
->name
.name
);
509 struct bfd_link_hash_entry
*h
;
511 = lang_symbol_definition_iteration (tree
->name
.name
);
513 h
= bfd_wrapped_link_hash_lookup (output_bfd
, &link_info
,
516 result
.value
= (h
!= NULL
517 && (h
->type
== bfd_link_hash_defined
518 || h
->type
== bfd_link_hash_defweak
519 || h
->type
== bfd_link_hash_common
)
520 && (def_iteration
== lang_statement_iteration
521 || def_iteration
== -1));
522 result
.section
= abs_output_section
;
523 result
.valid_p
= TRUE
;
527 if (tree
->name
.name
[0] == '.' && tree
->name
.name
[1] == 0)
529 if (allocation_done
!= lang_first_phase_enum
)
530 result
= new_rel_from_section (dot
, current_section
);
532 else if (allocation_done
!= lang_first_phase_enum
)
534 struct bfd_link_hash_entry
*h
;
536 h
= bfd_wrapped_link_hash_lookup (output_bfd
, &link_info
,
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 result
= new_abs (h
->u
.def
.value
);
546 else if (allocation_done
== lang_final_phase_enum
547 || allocation_done
== lang_allocating_phase_enum
)
549 asection
*output_section
;
551 output_section
= h
->u
.def
.section
->output_section
;
552 if (output_section
== NULL
)
553 einfo (_("%X%S: unresolvable symbol `%s' referenced in expression\n"),
557 lang_output_section_statement_type
*os
;
559 os
= (lang_output_section_statement_lookup
560 (bfd_get_section_name (output_bfd
,
563 /* FIXME: Is this correct if this section is
564 being linked with -R? */
565 result
= new_rel ((h
->u
.def
.value
566 + h
->u
.def
.section
->output_offset
),
572 else if (allocation_done
== lang_final_phase_enum
)
573 einfo (_("%F%S: undefined symbol `%s' referenced in expression\n"),
575 else if (h
->type
== bfd_link_hash_new
)
577 h
->type
= bfd_link_hash_undefined
;
578 h
->u
.undef
.abfd
= NULL
;
579 if (h
->und_next
== NULL
)
580 bfd_link_add_undef (link_info
.hash
, h
);
586 if (allocation_done
!= lang_first_phase_enum
)
588 lang_output_section_statement_type
*os
;
590 os
= lang_output_section_find (tree
->name
.name
);
591 if (os
&& os
->processed
> 0)
592 result
= new_rel (0, NULL
, os
);
597 if (allocation_done
!= lang_first_phase_enum
)
599 lang_output_section_statement_type
*os
;
601 os
= lang_output_section_find (tree
->name
.name
);
602 if (os
&& os
->processed
!= 0)
604 if (os
->load_base
== NULL
)
605 result
= new_rel (0, NULL
, os
);
607 result
= exp_fold_tree_no_dot (os
->load_base
,
615 if (allocation_done
!= lang_first_phase_enum
)
617 int opb
= bfd_octets_per_byte (output_bfd
);
618 lang_output_section_statement_type
*os
;
620 os
= lang_output_section_find (tree
->name
.name
);
621 if (os
&& os
->processed
> 0)
622 result
= new_abs (os
->bfd_section
->size
/ opb
);
635 exp_fold_tree (etree_type
*tree
,
636 lang_output_section_statement_type
*current_section
,
637 lang_phase_type allocation_done
,
641 etree_value_type result
;
645 result
.valid_p
= FALSE
;
649 switch (tree
->type
.node_class
)
652 result
= new_rel (tree
->value
.value
, tree
->value
.str
, current_section
);
656 if (allocation_done
!= lang_final_phase_enum
)
657 result
.valid_p
= FALSE
;
659 result
= new_rel ((tree
->rel
.value
660 + tree
->rel
.section
->output_section
->vma
661 + tree
->rel
.section
->output_offset
),
667 result
= exp_fold_tree (tree
->assert_s
.child
,
669 allocation_done
, dot
, dotp
);
673 einfo ("%F%P: %s\n", tree
->assert_s
.message
);
679 result
= fold_unary (tree
, current_section
, allocation_done
,
684 result
= fold_binary (tree
, current_section
, allocation_done
,
689 result
= fold_trinary (tree
, current_section
, allocation_done
,
696 if (tree
->assign
.dst
[0] == '.' && tree
->assign
.dst
[1] == 0)
698 /* Assignment to dot can only be done during allocation. */
699 if (tree
->type
.node_class
!= etree_assign
)
700 einfo (_("%F%S can not PROVIDE assignment to location counter\n"));
701 if (allocation_done
== lang_allocating_phase_enum
702 || (allocation_done
== lang_final_phase_enum
703 && current_section
== abs_output_section
))
705 result
= exp_fold_tree (tree
->assign
.src
,
707 allocation_done
, dot
,
709 if (! result
.valid_p
)
710 einfo (_("%F%S invalid assignment to location counter\n"));
713 if (current_section
== NULL
)
714 einfo (_("%F%S assignment to location counter invalid outside of SECTION\n"));
719 nextdot
= (result
.value
720 + current_section
->bfd_section
->vma
);
722 && current_section
!= abs_output_section
)
723 einfo (_("%F%S cannot move location counter backwards (from %V to %V)\n"),
733 result
= exp_fold_tree (tree
->assign
.src
,
734 current_section
, allocation_done
,
739 struct bfd_link_hash_entry
*h
;
741 if (tree
->type
.node_class
== etree_assign
)
745 h
= bfd_link_hash_lookup (link_info
.hash
, tree
->assign
.dst
,
746 create
, FALSE
, TRUE
);
750 einfo (_("%P%F:%s: hash creation failed\n"),
753 else if (tree
->type
.node_class
== etree_provide
754 && h
->type
!= bfd_link_hash_new
755 && h
->type
!= bfd_link_hash_undefined
756 && h
->type
!= bfd_link_hash_common
)
758 /* Do nothing. The symbol was defined by some
763 /* FIXME: Should we worry if the symbol is already
765 lang_update_definedness (tree
->assign
.dst
, h
);
766 h
->type
= bfd_link_hash_defined
;
767 h
->u
.def
.value
= result
.value
;
768 h
->u
.def
.section
= result
.section
->bfd_section
;
769 if (tree
->type
.node_class
== etree_provide
)
770 tree
->type
.node_class
= etree_provided
;
777 result
= fold_name (tree
, current_section
, allocation_done
, dot
);
788 static etree_value_type
789 exp_fold_tree_no_dot (etree_type
*tree
,
790 lang_output_section_statement_type
*current_section
,
791 lang_phase_type allocation_done
)
793 return exp_fold_tree (tree
, current_section
, allocation_done
, 0, NULL
);
797 exp_binop (int code
, etree_type
*lhs
, etree_type
*rhs
)
799 etree_type value
, *new;
802 value
.type
.node_code
= code
;
803 value
.binary
.lhs
= lhs
;
804 value
.binary
.rhs
= rhs
;
805 value
.type
.node_class
= etree_binary
;
806 r
= exp_fold_tree_no_dot (&value
,
808 lang_first_phase_enum
);
811 return exp_intop (r
.value
);
813 new = stat_alloc (sizeof (new->binary
));
814 memcpy (new, &value
, sizeof (new->binary
));
819 exp_trinop (int code
, etree_type
*cond
, etree_type
*lhs
, etree_type
*rhs
)
821 etree_type value
, *new;
823 value
.type
.node_code
= code
;
824 value
.trinary
.lhs
= lhs
;
825 value
.trinary
.cond
= cond
;
826 value
.trinary
.rhs
= rhs
;
827 value
.type
.node_class
= etree_trinary
;
828 r
= exp_fold_tree_no_dot (&value
, NULL
, lang_first_phase_enum
);
830 return exp_intop (r
.value
);
832 new = stat_alloc (sizeof (new->trinary
));
833 memcpy (new, &value
, sizeof (new->trinary
));
838 exp_unop (int code
, etree_type
*child
)
840 etree_type value
, *new;
843 value
.unary
.type
.node_code
= code
;
844 value
.unary
.child
= child
;
845 value
.unary
.type
.node_class
= etree_unary
;
846 r
= exp_fold_tree_no_dot (&value
, abs_output_section
,
847 lang_first_phase_enum
);
849 return exp_intop (r
.value
);
851 new = stat_alloc (sizeof (new->unary
));
852 memcpy (new, &value
, sizeof (new->unary
));
857 exp_nameop (int code
, const char *name
)
859 etree_type value
, *new;
861 value
.name
.type
.node_code
= code
;
862 value
.name
.name
= name
;
863 value
.name
.type
.node_class
= etree_name
;
865 r
= exp_fold_tree_no_dot (&value
, NULL
, lang_first_phase_enum
);
867 return exp_intop (r
.value
);
869 new = stat_alloc (sizeof (new->name
));
870 memcpy (new, &value
, sizeof (new->name
));
876 exp_assop (int code
, const char *dst
, etree_type
*src
)
878 etree_type value
, *new;
880 value
.assign
.type
.node_code
= code
;
882 value
.assign
.src
= src
;
883 value
.assign
.dst
= dst
;
884 value
.assign
.type
.node_class
= etree_assign
;
887 if (exp_fold_tree_no_dot (&value
, &result
))
888 return exp_intop (result
);
890 new = stat_alloc (sizeof (new->assign
));
891 memcpy (new, &value
, sizeof (new->assign
));
895 /* Handle PROVIDE. */
898 exp_provide (const char *dst
, etree_type
*src
)
902 n
= stat_alloc (sizeof (n
->assign
));
903 n
->assign
.type
.node_code
= '=';
904 n
->assign
.type
.node_class
= etree_provide
;
913 exp_assert (etree_type
*exp
, const char *message
)
917 n
= stat_alloc (sizeof (n
->assert_s
));
918 n
->assert_s
.type
.node_code
= '!';
919 n
->assert_s
.type
.node_class
= etree_assert
;
920 n
->assert_s
.child
= exp
;
921 n
->assert_s
.message
= message
;
926 exp_print_tree (etree_type
*tree
)
928 if (config
.map_file
== NULL
)
929 config
.map_file
= stderr
;
933 minfo ("NULL TREE\n");
937 switch (tree
->type
.node_class
)
940 minfo ("0x%v", tree
->value
.value
);
943 if (tree
->rel
.section
->owner
!= NULL
)
944 minfo ("%B:", tree
->rel
.section
->owner
);
945 minfo ("%s+0x%v", tree
->rel
.section
->name
, tree
->rel
.value
);
949 if (tree
->assign
.dst
->sdefs
!= NULL
)
950 fprintf (config
.map_file
, "%s (%x) ", tree
->assign
.dst
->name
,
951 tree
->assign
.dst
->sdefs
->value
);
953 fprintf (config
.map_file
, "%s (UNDEFINED)", tree
->assign
.dst
->name
);
955 fprintf (config
.map_file
, "%s", tree
->assign
.dst
);
956 exp_print_token (tree
->type
.node_code
, TRUE
);
957 exp_print_tree (tree
->assign
.src
);
961 fprintf (config
.map_file
, "PROVIDE (%s, ", tree
->assign
.dst
);
962 exp_print_tree (tree
->assign
.src
);
963 fprintf (config
.map_file
, ")");
966 fprintf (config
.map_file
, "(");
967 exp_print_tree (tree
->binary
.lhs
);
968 exp_print_token (tree
->type
.node_code
, TRUE
);
969 exp_print_tree (tree
->binary
.rhs
);
970 fprintf (config
.map_file
, ")");
973 exp_print_tree (tree
->trinary
.cond
);
974 fprintf (config
.map_file
, "?");
975 exp_print_tree (tree
->trinary
.lhs
);
976 fprintf (config
.map_file
, ":");
977 exp_print_tree (tree
->trinary
.rhs
);
980 exp_print_token (tree
->unary
.type
.node_code
, FALSE
);
981 if (tree
->unary
.child
)
983 fprintf (config
.map_file
, " (");
984 exp_print_tree (tree
->unary
.child
);
985 fprintf (config
.map_file
, ")");
990 fprintf (config
.map_file
, "ASSERT (");
991 exp_print_tree (tree
->assert_s
.child
);
992 fprintf (config
.map_file
, ", %s)", tree
->assert_s
.message
);
996 fprintf (config
.map_file
, "????????");
999 if (tree
->type
.node_code
== NAME
)
1001 fprintf (config
.map_file
, "%s", tree
->name
.name
);
1005 exp_print_token (tree
->type
.node_code
, FALSE
);
1006 if (tree
->name
.name
)
1007 fprintf (config
.map_file
, " (%s)", tree
->name
.name
);
1017 exp_get_vma (etree_type
*tree
,
1020 lang_phase_type allocation_done
)
1026 r
= exp_fold_tree_no_dot (tree
, abs_output_section
, allocation_done
);
1027 if (! r
.valid_p
&& name
!= NULL
)
1028 einfo (_("%F%S nonconstant expression for %s\n"), name
);
1036 exp_get_value_int (etree_type
*tree
,
1039 lang_phase_type allocation_done
)
1041 return exp_get_vma (tree
, def
, name
, allocation_done
);
1045 exp_get_fill (etree_type
*tree
,
1048 lang_phase_type allocation_done
)
1058 r
= exp_fold_tree_no_dot (tree
, abs_output_section
, allocation_done
);
1059 if (! r
.valid_p
&& name
!= NULL
)
1060 einfo (_("%F%S nonconstant expression for %s\n"), name
);
1062 if (r
.str
!= NULL
&& (len
= strlen (r
.str
)) != 0)
1066 fill
= xmalloc ((len
+ 1) / 2 + sizeof (*fill
) - 1);
1067 fill
->size
= (len
+ 1) / 2;
1077 digit
= (digit
- 'A' + '0' + 10) & 0xf;
1091 fill
= xmalloc (4 + sizeof (*fill
) - 1);
1093 fill
->data
[0] = (val
>> 24) & 0xff;
1094 fill
->data
[1] = (val
>> 16) & 0xff;
1095 fill
->data
[2] = (val
>> 8) & 0xff;
1096 fill
->data
[3] = (val
>> 0) & 0xff;
1103 exp_get_abs_int (etree_type
*tree
,
1104 int def ATTRIBUTE_UNUSED
,
1106 lang_phase_type allocation_done
)
1108 etree_value_type res
;
1109 res
= exp_fold_tree_no_dot (tree
, abs_output_section
, allocation_done
);
1112 res
.value
+= res
.section
->bfd_section
->vma
;
1114 einfo (_("%F%S non constant expression for %s\n"), name
);
1120 align_n (bfd_vma value
, bfd_vma align
)
1125 value
= (value
+ align
- 1) / align
;
1126 return value
* align
;