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_END
:
269 if (allocation_done
!= lang_first_phase_enum
270 && current_section
== abs_output_section
271 && (exp_data_seg
.phase
== exp_dataseg_align_seen
272 || exp_data_seg
.phase
== exp_dataseg_relro_seen
273 || exp_data_seg
.phase
== exp_dataseg_adjust
274 || exp_data_seg
.phase
== exp_dataseg_relro_adjust
275 || allocation_done
!= lang_allocating_phase_enum
))
277 if (exp_data_seg
.phase
== exp_dataseg_align_seen
278 || exp_data_seg
.phase
== exp_dataseg_relro_seen
)
280 exp_data_seg
.phase
= exp_dataseg_end_seen
;
281 exp_data_seg
.end
= result
.value
;
285 result
.valid_p
= FALSE
;
297 static etree_value_type
298 fold_binary (etree_type
*tree
,
299 lang_output_section_statement_type
*current_section
,
300 lang_phase_type allocation_done
,
304 etree_value_type result
;
306 result
= exp_fold_tree (tree
->binary
.lhs
, current_section
,
307 allocation_done
, dot
, dotp
);
310 etree_value_type other
;
312 other
= exp_fold_tree (tree
->binary
.rhs
,
314 allocation_done
, dot
, dotp
);
317 /* If the values are from different sections, or this is an
318 absolute expression, make both the source arguments
319 absolute. However, adding or subtracting an absolute
320 value from a relative value is meaningful, and is an
322 if (current_section
!= abs_output_section
323 && (other
.section
== abs_output_section
324 || (result
.section
== abs_output_section
325 && tree
->type
.node_code
== '+'))
326 && (tree
->type
.node_code
== '+'
327 || tree
->type
.node_code
== '-'))
329 if (other
.section
!= abs_output_section
)
331 /* Keep the section of the other term. */
332 if (tree
->type
.node_code
== '+')
333 other
.value
= result
.value
+ other
.value
;
335 other
.value
= result
.value
- other
.value
;
339 else if (result
.section
!= other
.section
340 || current_section
== abs_output_section
)
346 switch (tree
->type
.node_code
)
349 if (other
.value
== 0)
350 einfo (_("%F%S %% by zero\n"));
351 result
.value
= ((bfd_signed_vma
) result
.value
352 % (bfd_signed_vma
) other
.value
);
356 if (other
.value
== 0)
357 einfo (_("%F%S / by zero\n"));
358 result
.value
= ((bfd_signed_vma
) result
.value
359 / (bfd_signed_vma
) other
.value
);
362 #define BOP(x,y) case x : result.value = result.value y other.value; break;
381 if (result
.value
< other
.value
)
386 if (result
.value
> other
.value
)
391 result
.value
= align_n (result
.value
, other
.value
);
394 case DATA_SEGMENT_ALIGN
:
395 if (allocation_done
!= lang_first_phase_enum
396 && current_section
== abs_output_section
397 && (exp_data_seg
.phase
== exp_dataseg_none
398 || exp_data_seg
.phase
== exp_dataseg_adjust
399 || exp_data_seg
.phase
== exp_dataseg_relro_adjust
400 || allocation_done
!= lang_allocating_phase_enum
))
402 bfd_vma maxpage
= result
.value
;
404 result
.value
= align_n (dot
, maxpage
);
405 if (exp_data_seg
.phase
== exp_dataseg_relro_adjust
)
406 result
.value
= exp_data_seg
.base
;
407 else if (exp_data_seg
.phase
!= exp_dataseg_adjust
)
409 result
.value
+= dot
& (maxpage
- 1);
410 if (allocation_done
== lang_allocating_phase_enum
)
412 exp_data_seg
.phase
= exp_dataseg_align_seen
;
413 exp_data_seg
.base
= result
.value
;
414 exp_data_seg
.pagesize
= other
.value
;
415 exp_data_seg
.relro_end
= 0;
418 else if (other
.value
< maxpage
)
419 result
.value
+= (dot
+ other
.value
- 1)
420 & (maxpage
- other
.value
);
423 result
.valid_p
= FALSE
;
426 case DATA_SEGMENT_RELRO_END
:
427 if (allocation_done
!= lang_first_phase_enum
428 && (exp_data_seg
.phase
== exp_dataseg_align_seen
429 || exp_data_seg
.phase
== exp_dataseg_adjust
430 || exp_data_seg
.phase
== exp_dataseg_relro_adjust
431 || allocation_done
!= lang_allocating_phase_enum
))
433 if (exp_data_seg
.phase
== exp_dataseg_align_seen
434 || exp_data_seg
.phase
== exp_dataseg_relro_adjust
)
435 exp_data_seg
.relro_end
436 = result
.value
+ other
.value
;
437 if (exp_data_seg
.phase
== exp_dataseg_relro_adjust
438 && (exp_data_seg
.relro_end
439 & (exp_data_seg
.pagesize
- 1)))
441 exp_data_seg
.relro_end
+= exp_data_seg
.pagesize
- 1;
442 exp_data_seg
.relro_end
&= ~(exp_data_seg
.pagesize
- 1);
443 result
.value
= exp_data_seg
.relro_end
- other
.value
;
445 if (exp_data_seg
.phase
== exp_dataseg_align_seen
)
446 exp_data_seg
.phase
= exp_dataseg_relro_seen
;
449 result
.valid_p
= FALSE
;
458 result
.valid_p
= FALSE
;
465 static etree_value_type
466 fold_trinary (etree_type
*tree
,
467 lang_output_section_statement_type
*current_section
,
468 lang_phase_type allocation_done
,
472 etree_value_type result
;
474 result
= exp_fold_tree (tree
->trinary
.cond
, current_section
,
475 allocation_done
, dot
, dotp
);
477 result
= exp_fold_tree ((result
.value
479 : tree
->trinary
.rhs
),
481 allocation_done
, dot
, dotp
);
486 static etree_value_type
487 fold_name (etree_type
*tree
,
488 lang_output_section_statement_type
*current_section
,
489 lang_phase_type allocation_done
,
492 etree_value_type result
;
494 result
.valid_p
= FALSE
;
496 switch (tree
->type
.node_code
)
499 if (allocation_done
!= lang_first_phase_enum
)
500 result
= new_abs (bfd_sizeof_headers (output_bfd
,
501 link_info
.relocatable
));
504 if (allocation_done
== lang_first_phase_enum
)
505 lang_track_definedness (tree
->name
.name
);
508 struct bfd_link_hash_entry
*h
;
510 = lang_symbol_definition_iteration (tree
->name
.name
);
512 h
= bfd_wrapped_link_hash_lookup (output_bfd
, &link_info
,
515 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 result
.section
= abs_output_section
;
522 result
.valid_p
= TRUE
;
526 if (tree
->name
.name
[0] == '.' && tree
->name
.name
[1] == 0)
528 if (allocation_done
!= lang_first_phase_enum
)
529 result
= new_rel_from_section (dot
, current_section
);
531 else if (allocation_done
!= lang_first_phase_enum
)
533 struct bfd_link_hash_entry
*h
;
535 h
= bfd_wrapped_link_hash_lookup (output_bfd
, &link_info
,
539 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
540 else if (h
->type
== bfd_link_hash_defined
541 || h
->type
== bfd_link_hash_defweak
)
543 if (bfd_is_abs_section (h
->u
.def
.section
))
544 result
= new_abs (h
->u
.def
.value
);
545 else if (allocation_done
== lang_final_phase_enum
546 || allocation_done
== lang_allocating_phase_enum
)
548 asection
*output_section
;
550 output_section
= h
->u
.def
.section
->output_section
;
551 if (output_section
== NULL
)
552 einfo (_("%X%S: unresolvable symbol `%s' referenced in expression\n"),
556 lang_output_section_statement_type
*os
;
558 os
= (lang_output_section_statement_lookup
559 (bfd_get_section_name (output_bfd
,
562 /* FIXME: Is this correct if this section is
563 being linked with -R? */
564 result
= new_rel ((h
->u
.def
.value
565 + h
->u
.def
.section
->output_offset
),
571 else if (allocation_done
== lang_final_phase_enum
)
572 einfo (_("%F%S: undefined symbol `%s' referenced in expression\n"),
574 else if (h
->type
== bfd_link_hash_new
)
576 h
->type
= bfd_link_hash_undefined
;
577 h
->u
.undef
.abfd
= NULL
;
578 if (h
->u
.undef
.next
== NULL
)
579 bfd_link_add_undef (link_info
.hash
, h
);
585 if (allocation_done
!= lang_first_phase_enum
)
587 lang_output_section_statement_type
*os
;
589 os
= lang_output_section_find (tree
->name
.name
);
590 if (os
&& os
->processed
> 0)
591 result
= new_rel (0, NULL
, os
);
596 if (allocation_done
!= lang_first_phase_enum
)
598 lang_output_section_statement_type
*os
;
600 os
= lang_output_section_find (tree
->name
.name
);
601 if (os
&& os
->processed
!= 0)
603 if (os
->load_base
== NULL
)
604 result
= new_rel (0, NULL
, os
);
606 result
= exp_fold_tree_no_dot (os
->load_base
,
614 if (allocation_done
!= lang_first_phase_enum
)
616 int opb
= bfd_octets_per_byte (output_bfd
);
617 lang_output_section_statement_type
*os
;
619 os
= lang_output_section_find (tree
->name
.name
);
620 if (os
&& os
->processed
> 0)
621 result
= new_abs (os
->bfd_section
->size
/ opb
);
634 exp_fold_tree (etree_type
*tree
,
635 lang_output_section_statement_type
*current_section
,
636 lang_phase_type allocation_done
,
640 etree_value_type result
;
644 result
.valid_p
= FALSE
;
648 switch (tree
->type
.node_class
)
651 result
= new_rel (tree
->value
.value
, tree
->value
.str
, current_section
);
655 if (allocation_done
!= lang_final_phase_enum
)
656 result
.valid_p
= FALSE
;
658 result
= new_rel ((tree
->rel
.value
659 + tree
->rel
.section
->output_section
->vma
660 + tree
->rel
.section
->output_offset
),
666 result
= exp_fold_tree (tree
->assert_s
.child
,
668 allocation_done
, dot
, dotp
);
672 einfo ("%F%P: %s\n", tree
->assert_s
.message
);
678 result
= fold_unary (tree
, current_section
, allocation_done
,
683 result
= fold_binary (tree
, current_section
, allocation_done
,
688 result
= fold_trinary (tree
, current_section
, allocation_done
,
695 if (tree
->assign
.dst
[0] == '.' && tree
->assign
.dst
[1] == 0)
697 /* Assignment to dot can only be done during allocation. */
698 if (tree
->type
.node_class
!= etree_assign
)
699 einfo (_("%F%S can not PROVIDE assignment to location counter\n"));
700 if (allocation_done
== lang_allocating_phase_enum
701 || (allocation_done
== lang_final_phase_enum
702 && current_section
== abs_output_section
))
704 result
= exp_fold_tree (tree
->assign
.src
,
706 allocation_done
, dot
,
708 if (! result
.valid_p
)
709 einfo (_("%F%S invalid assignment to location counter\n"));
712 if (current_section
== NULL
)
713 einfo (_("%F%S assignment to location counter invalid outside of SECTION\n"));
718 nextdot
= (result
.value
719 + current_section
->bfd_section
->vma
);
721 && current_section
!= abs_output_section
)
722 einfo (_("%F%S cannot move location counter backwards (from %V to %V)\n"),
732 result
= exp_fold_tree (tree
->assign
.src
,
733 current_section
, allocation_done
,
738 struct bfd_link_hash_entry
*h
;
740 if (tree
->type
.node_class
== etree_assign
)
744 h
= bfd_link_hash_lookup (link_info
.hash
, tree
->assign
.dst
,
745 create
, FALSE
, TRUE
);
749 einfo (_("%P%F:%s: hash creation failed\n"),
752 else if (tree
->type
.node_class
== etree_provide
753 && h
->type
!= bfd_link_hash_new
754 && h
->type
!= bfd_link_hash_undefined
755 && h
->type
!= bfd_link_hash_common
)
757 /* Do nothing. The symbol was defined by some
762 /* FIXME: Should we worry if the symbol is already
764 lang_update_definedness (tree
->assign
.dst
, h
);
765 h
->type
= bfd_link_hash_defined
;
766 h
->u
.def
.value
= result
.value
;
767 h
->u
.def
.section
= result
.section
->bfd_section
;
768 if (tree
->type
.node_class
== etree_provide
)
769 tree
->type
.node_class
= etree_provided
;
776 result
= fold_name (tree
, current_section
, allocation_done
, dot
);
787 static etree_value_type
788 exp_fold_tree_no_dot (etree_type
*tree
,
789 lang_output_section_statement_type
*current_section
,
790 lang_phase_type allocation_done
)
792 return exp_fold_tree (tree
, current_section
, allocation_done
, 0, NULL
);
796 exp_binop (int code
, etree_type
*lhs
, etree_type
*rhs
)
798 etree_type value
, *new;
801 value
.type
.node_code
= code
;
802 value
.binary
.lhs
= lhs
;
803 value
.binary
.rhs
= rhs
;
804 value
.type
.node_class
= etree_binary
;
805 r
= exp_fold_tree_no_dot (&value
,
807 lang_first_phase_enum
);
810 return exp_intop (r
.value
);
812 new = stat_alloc (sizeof (new->binary
));
813 memcpy (new, &value
, sizeof (new->binary
));
818 exp_trinop (int code
, etree_type
*cond
, etree_type
*lhs
, etree_type
*rhs
)
820 etree_type value
, *new;
822 value
.type
.node_code
= code
;
823 value
.trinary
.lhs
= lhs
;
824 value
.trinary
.cond
= cond
;
825 value
.trinary
.rhs
= rhs
;
826 value
.type
.node_class
= etree_trinary
;
827 r
= exp_fold_tree_no_dot (&value
, NULL
, lang_first_phase_enum
);
829 return exp_intop (r
.value
);
831 new = stat_alloc (sizeof (new->trinary
));
832 memcpy (new, &value
, sizeof (new->trinary
));
837 exp_unop (int code
, etree_type
*child
)
839 etree_type value
, *new;
842 value
.unary
.type
.node_code
= code
;
843 value
.unary
.child
= child
;
844 value
.unary
.type
.node_class
= etree_unary
;
845 r
= exp_fold_tree_no_dot (&value
, abs_output_section
,
846 lang_first_phase_enum
);
848 return exp_intop (r
.value
);
850 new = stat_alloc (sizeof (new->unary
));
851 memcpy (new, &value
, sizeof (new->unary
));
856 exp_nameop (int code
, const char *name
)
858 etree_type value
, *new;
860 value
.name
.type
.node_code
= code
;
861 value
.name
.name
= name
;
862 value
.name
.type
.node_class
= etree_name
;
864 r
= exp_fold_tree_no_dot (&value
, NULL
, lang_first_phase_enum
);
866 return exp_intop (r
.value
);
868 new = stat_alloc (sizeof (new->name
));
869 memcpy (new, &value
, sizeof (new->name
));
875 exp_assop (int code
, const char *dst
, etree_type
*src
)
877 etree_type value
, *new;
879 value
.assign
.type
.node_code
= code
;
881 value
.assign
.src
= src
;
882 value
.assign
.dst
= dst
;
883 value
.assign
.type
.node_class
= etree_assign
;
886 if (exp_fold_tree_no_dot (&value
, &result
))
887 return exp_intop (result
);
889 new = stat_alloc (sizeof (new->assign
));
890 memcpy (new, &value
, sizeof (new->assign
));
894 /* Handle PROVIDE. */
897 exp_provide (const char *dst
, etree_type
*src
)
901 n
= stat_alloc (sizeof (n
->assign
));
902 n
->assign
.type
.node_code
= '=';
903 n
->assign
.type
.node_class
= etree_provide
;
912 exp_assert (etree_type
*exp
, const char *message
)
916 n
= stat_alloc (sizeof (n
->assert_s
));
917 n
->assert_s
.type
.node_code
= '!';
918 n
->assert_s
.type
.node_class
= etree_assert
;
919 n
->assert_s
.child
= exp
;
920 n
->assert_s
.message
= message
;
925 exp_print_tree (etree_type
*tree
)
927 if (config
.map_file
== NULL
)
928 config
.map_file
= stderr
;
932 minfo ("NULL TREE\n");
936 switch (tree
->type
.node_class
)
939 minfo ("0x%v", tree
->value
.value
);
942 if (tree
->rel
.section
->owner
!= NULL
)
943 minfo ("%B:", tree
->rel
.section
->owner
);
944 minfo ("%s+0x%v", tree
->rel
.section
->name
, tree
->rel
.value
);
948 if (tree
->assign
.dst
->sdefs
!= NULL
)
949 fprintf (config
.map_file
, "%s (%x) ", tree
->assign
.dst
->name
,
950 tree
->assign
.dst
->sdefs
->value
);
952 fprintf (config
.map_file
, "%s (UNDEFINED)", tree
->assign
.dst
->name
);
954 fprintf (config
.map_file
, "%s", tree
->assign
.dst
);
955 exp_print_token (tree
->type
.node_code
, TRUE
);
956 exp_print_tree (tree
->assign
.src
);
960 fprintf (config
.map_file
, "PROVIDE (%s, ", tree
->assign
.dst
);
961 exp_print_tree (tree
->assign
.src
);
962 fprintf (config
.map_file
, ")");
965 fprintf (config
.map_file
, "(");
966 exp_print_tree (tree
->binary
.lhs
);
967 exp_print_token (tree
->type
.node_code
, TRUE
);
968 exp_print_tree (tree
->binary
.rhs
);
969 fprintf (config
.map_file
, ")");
972 exp_print_tree (tree
->trinary
.cond
);
973 fprintf (config
.map_file
, "?");
974 exp_print_tree (tree
->trinary
.lhs
);
975 fprintf (config
.map_file
, ":");
976 exp_print_tree (tree
->trinary
.rhs
);
979 exp_print_token (tree
->unary
.type
.node_code
, FALSE
);
980 if (tree
->unary
.child
)
982 fprintf (config
.map_file
, " (");
983 exp_print_tree (tree
->unary
.child
);
984 fprintf (config
.map_file
, ")");
989 fprintf (config
.map_file
, "ASSERT (");
990 exp_print_tree (tree
->assert_s
.child
);
991 fprintf (config
.map_file
, ", %s)", tree
->assert_s
.message
);
995 fprintf (config
.map_file
, "????????");
998 if (tree
->type
.node_code
== NAME
)
1000 fprintf (config
.map_file
, "%s", tree
->name
.name
);
1004 exp_print_token (tree
->type
.node_code
, FALSE
);
1005 if (tree
->name
.name
)
1006 fprintf (config
.map_file
, " (%s)", tree
->name
.name
);
1016 exp_get_vma (etree_type
*tree
,
1019 lang_phase_type allocation_done
)
1025 r
= exp_fold_tree_no_dot (tree
, abs_output_section
, allocation_done
);
1026 if (! r
.valid_p
&& name
!= NULL
)
1027 einfo (_("%F%S nonconstant expression for %s\n"), name
);
1035 exp_get_value_int (etree_type
*tree
,
1038 lang_phase_type allocation_done
)
1040 return exp_get_vma (tree
, def
, name
, allocation_done
);
1044 exp_get_fill (etree_type
*tree
,
1047 lang_phase_type allocation_done
)
1057 r
= exp_fold_tree_no_dot (tree
, abs_output_section
, allocation_done
);
1058 if (! r
.valid_p
&& name
!= NULL
)
1059 einfo (_("%F%S nonconstant expression for %s\n"), name
);
1061 if (r
.str
!= NULL
&& (len
= strlen (r
.str
)) != 0)
1065 fill
= xmalloc ((len
+ 1) / 2 + sizeof (*fill
) - 1);
1066 fill
->size
= (len
+ 1) / 2;
1076 digit
= (digit
- 'A' + '0' + 10) & 0xf;
1090 fill
= xmalloc (4 + sizeof (*fill
) - 1);
1092 fill
->data
[0] = (val
>> 24) & 0xff;
1093 fill
->data
[1] = (val
>> 16) & 0xff;
1094 fill
->data
[2] = (val
>> 8) & 0xff;
1095 fill
->data
[3] = (val
>> 0) & 0xff;
1102 exp_get_abs_int (etree_type
*tree
,
1103 int def ATTRIBUTE_UNUSED
,
1105 lang_phase_type allocation_done
)
1107 etree_value_type res
;
1108 res
= exp_fold_tree_no_dot (tree
, abs_output_section
, allocation_done
);
1111 res
.value
+= res
.section
->bfd_section
->vma
;
1113 einfo (_("%F%S non constant expression for %s\n"), name
);
1119 align_n (bfd_vma value
, bfd_vma align
)
1124 value
= (value
+ align
- 1) / align
;
1125 return value
* align
;