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
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, 51 Franklin Street - Fifth Floor, 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 void exp_fold_tree_1 (etree_type *);
45 static void exp_fold_tree_no_dot (etree_type *);
46 static bfd_vma align_n (bfd_vma, bfd_vma);
48 segment_type *segments;
50 struct ldexp_control expld;
52 /* Print the string representation of the given token. Surround it
53 with spaces if INFIX_P is TRUE. */
56 exp_print_token (token_code_type code, int infix_p)
90 { SECTIONS, "SECTIONS" },
91 { SIZEOF_HEADERS, "SIZEOF_HEADERS" },
93 { DEFINED, "DEFINED" },
94 { TARGET_K, "TARGET" },
95 { SEARCH_DIR, "SEARCH_DIR" },
101 { LOADADDR, "LOADADDR" },
102 { CONSTANT, "CONSTANT" },
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);
135 expld.result.value += expld.result.section->vma;
136 expld.result.section = bfd_abs_section_ptr;
140 new_abs (bfd_vma value)
142 expld.result.valid_p = TRUE;
143 expld.result.section = bfd_abs_section_ptr;
144 expld.result.value = value;
145 expld.result.str = NULL;
149 exp_intop (bfd_vma value)
151 etree_type *new = stat_alloc (sizeof (new->value));
152 new->type.node_code = INT;
153 new->value.value = value;
154 new->value.str = NULL;
155 new->type.node_class = etree_value;
160 exp_bigintop (bfd_vma value, char *str)
162 etree_type *new = stat_alloc (sizeof (new->value));
163 new->type.node_code = INT;
164 new->value.value = value;
165 new->value.str = str;
166 new->type.node_class = etree_value;
170 /* Build an expression representing an unnamed relocatable value. */
173 exp_relop (asection *section, bfd_vma value)
175 etree_type *new = stat_alloc (sizeof (new->rel));
176 new->type.node_code = REL;
177 new->type.node_class = etree_rel;
178 new->rel.section = section;
179 new->rel.value = value;
184 new_rel (bfd_vma value, char *str, asection *section)
186 expld.result.valid_p = TRUE;
187 expld.result.value = value;
188 expld.result.str = str;
189 expld.result.section = section;
193 new_rel_from_abs (bfd_vma value)
195 expld.result.valid_p = TRUE;
196 expld.result.value = value - expld.section->vma;
197 expld.result.str = NULL;
198 expld.result.section = expld.section;
202 fold_unary (etree_type *tree)
204 exp_fold_tree_1 (tree->unary.child);
205 if (expld.result.valid_p)
207 switch (tree->type.node_code)
210 if (expld.phase != lang_first_phase_enum)
211 new_rel_from_abs (align_n (expld.dot, expld.result.value));
213 expld.result.valid_p = FALSE;
222 expld.result.value = ~expld.result.value;
227 expld.result.value = !expld.result.value;
232 expld.result.value = -expld.result.value;
236 /* Return next place aligned to value. */
237 if (expld.phase != lang_first_phase_enum)
240 expld.result.value = align_n (expld.dot, expld.result.value);
243 expld.result.valid_p = FALSE;
246 case DATA_SEGMENT_END:
247 if (expld.phase != lang_first_phase_enum
248 && expld.section == bfd_abs_section_ptr
249 && (expld.dataseg.phase == exp_dataseg_align_seen
250 || expld.dataseg.phase == exp_dataseg_relro_seen
251 || expld.dataseg.phase == exp_dataseg_adjust
252 || expld.dataseg.phase == exp_dataseg_relro_adjust
253 || expld.phase == lang_final_phase_enum))
255 if (expld.dataseg.phase == exp_dataseg_align_seen
256 || expld.dataseg.phase == exp_dataseg_relro_seen)
258 expld.dataseg.phase = exp_dataseg_end_seen;
259 expld.dataseg.end = expld.result.value;
263 expld.result.valid_p = FALSE;
274 fold_binary (etree_type *tree)
276 exp_fold_tree_1 (tree->binary.lhs);
278 /* The SEGMENT_START operator is special because its first
279 operand is a string, not the name of a symbol. */
280 if (expld.result.valid_p && tree->type.node_code == SEGMENT_START)
282 const char *segment_name;
284 /* Check to see if the user has overridden the default
286 segment_name = tree->binary.rhs->name.name;
287 for (seg = segments; seg; seg = seg->next)
288 if (strcmp (seg->name, segment_name) == 0)
291 expld.result.value = seg->value;
292 expld.result.str = NULL;
293 expld.result.section = NULL;
297 else if (expld.result.valid_p)
299 etree_value_type lhs = expld.result;
301 exp_fold_tree_1 (tree->binary.rhs);
302 if (expld.result.valid_p)
304 /* If the values are from different sections, or this is an
305 absolute expression, make both the source arguments
306 absolute. However, adding or subtracting an absolute
307 value from a relative value is meaningful, and is an
309 if (expld.section != bfd_abs_section_ptr
310 && lhs.section == bfd_abs_section_ptr
311 && tree->type.node_code == '+')
313 /* Keep the section of the rhs term. */
314 expld.result.value = lhs.value + expld.result.value;
317 else if (expld.section != bfd_abs_section_ptr
318 && expld.result.section == bfd_abs_section_ptr
319 && (tree->type.node_code == '+'
320 || tree->type.node_code == '-'))
322 /* Keep the section of the lhs term. */
323 expld.result.section = lhs.section;
325 else if (expld.result.section != lhs.section
326 || expld.section == bfd_abs_section_ptr)
329 lhs.value += lhs.section->vma;
332 switch (tree->type.node_code)
335 if (expld.result.value != 0)
336 expld.result.value = ((bfd_signed_vma) lhs.value
337 % (bfd_signed_vma) expld.result.value);
338 else if (expld.phase != lang_mark_phase_enum)
339 einfo (_("%F%S %% by zero\n"));
343 if (expld.result.value != 0)
344 expld.result.value = ((bfd_signed_vma) lhs.value
345 / (bfd_signed_vma) expld.result.value);
346 else if (expld.phase != lang_mark_phase_enum)
347 einfo (_("%F%S / by zero\n"));
352 expld.result.value = lhs.value y expld.result.value; \
373 if (lhs.value > expld.result.value)
374 expld.result.value = lhs.value;
378 if (lhs.value < expld.result.value)
379 expld.result.value = lhs.value;
383 expld.result.value = align_n (lhs.value, expld.result.value);
386 case DATA_SEGMENT_ALIGN:
387 if (expld.phase != lang_first_phase_enum
388 && expld.section == bfd_abs_section_ptr
389 && (expld.dataseg.phase == exp_dataseg_none
390 || expld.dataseg.phase == exp_dataseg_adjust
391 || expld.dataseg.phase == exp_dataseg_relro_adjust
392 || expld.phase == lang_final_phase_enum))
394 bfd_vma maxpage = lhs.value;
395 bfd_vma commonpage = expld.result.value;
397 expld.result.value = align_n (expld.dot, maxpage);
398 if (expld.dataseg.phase == exp_dataseg_relro_adjust)
399 expld.result.value = expld.dataseg.base;
400 else if (expld.dataseg.phase != exp_dataseg_adjust)
402 expld.result.value += expld.dot & (maxpage - 1);
403 if (expld.phase == lang_allocating_phase_enum)
405 expld.dataseg.phase = exp_dataseg_align_seen;
406 expld.dataseg.min_base = align_n (expld.dot, maxpage);
407 expld.dataseg.base = expld.result.value;
408 expld.dataseg.pagesize = commonpage;
409 expld.dataseg.maxpagesize = maxpage;
410 expld.dataseg.relro_end = 0;
413 else if (commonpage < maxpage)
414 expld.result.value += ((expld.dot + commonpage - 1)
415 & (maxpage - commonpage));
418 expld.result.valid_p = FALSE;
421 case DATA_SEGMENT_RELRO_END:
422 if (expld.phase != lang_first_phase_enum
423 && (expld.dataseg.phase == exp_dataseg_align_seen
424 || expld.dataseg.phase == exp_dataseg_adjust
425 || expld.dataseg.phase == exp_dataseg_relro_adjust
426 || expld.phase == lang_final_phase_enum))
428 if (expld.dataseg.phase == exp_dataseg_align_seen
429 || expld.dataseg.phase == exp_dataseg_relro_adjust)
430 expld.dataseg.relro_end = lhs.value + expld.result.value;
432 if (expld.dataseg.phase == exp_dataseg_relro_adjust
433 && (expld.dataseg.relro_end
434 & (expld.dataseg.pagesize - 1)))
436 expld.dataseg.relro_end += expld.dataseg.pagesize - 1;
437 expld.dataseg.relro_end &= ~(expld.dataseg.pagesize - 1);
438 expld.result.value = (expld.dataseg.relro_end
439 - expld.result.value);
442 expld.result.value = lhs.value;
444 if (expld.dataseg.phase == exp_dataseg_align_seen)
445 expld.dataseg.phase = exp_dataseg_relro_seen;
448 expld.result.valid_p = FALSE;
456 expld.result.valid_p = FALSE;
461 fold_trinary (etree_type *tree)
463 exp_fold_tree_1 (tree->trinary.cond);
464 if (expld.result.valid_p)
465 exp_fold_tree_1 (expld.result.value
467 : tree->trinary.rhs);
471 fold_name (etree_type *tree)
473 memset (&expld.result, 0, sizeof (expld.result));
475 switch (tree->type.node_code)
478 if (expld.phase != lang_first_phase_enum)
480 bfd_vma hdr_size = 0;
481 /* Don't find the real header size if only marking sections;
482 The bfd function may cache incorrect data. */
483 if (expld.phase != lang_mark_phase_enum)
484 hdr_size = bfd_sizeof_headers (output_bfd, &link_info);
490 if (expld.phase == lang_first_phase_enum)
491 lang_track_definedness (tree->name.name);
494 struct bfd_link_hash_entry *h;
496 = lang_symbol_definition_iteration (tree->name.name);
498 h = bfd_wrapped_link_hash_lookup (output_bfd, &link_info,
501 expld.result.value = (h != NULL
502 && (h->type == bfd_link_hash_defined
503 || h->type == bfd_link_hash_defweak
504 || h->type == bfd_link_hash_common)
505 && (def_iteration == lang_statement_iteration
506 || def_iteration == -1));
507 expld.result.section = bfd_abs_section_ptr;
508 expld.result.valid_p = TRUE;
513 if (expld.phase == lang_first_phase_enum)
515 else if (tree->name.name[0] == '.' && tree->name.name[1] == 0)
516 new_rel_from_abs (expld.dot);
519 struct bfd_link_hash_entry *h;
521 h = bfd_wrapped_link_hash_lookup (output_bfd, &link_info,
525 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
526 else if (h->type == bfd_link_hash_defined
527 || h->type == bfd_link_hash_defweak)
529 if (bfd_is_abs_section (h->u.def.section))
530 new_abs (h->u.def.value);
533 asection *output_section;
535 output_section = h->u.def.section->output_section;
536 if (output_section == NULL)
538 if (expld.phase != lang_mark_phase_enum)
539 einfo (_("%X%S: unresolvable symbol `%s'"
540 " referenced in expression\n"),
544 new_rel (h->u.def.value + h->u.def.section->output_offset,
545 NULL, output_section);
548 else if (expld.phase == lang_final_phase_enum
549 || expld.assigning_to_dot)
550 einfo (_("%F%S: undefined symbol `%s' referenced in expression\n"),
552 else if (h->type == bfd_link_hash_new)
554 h->type = bfd_link_hash_undefined;
555 h->u.undef.abfd = NULL;
556 if (h->u.undef.next == NULL && h != link_info.hash->undefs_tail)
557 bfd_link_add_undef (link_info.hash, h);
563 if (expld.phase != lang_first_phase_enum)
565 lang_output_section_statement_type *os;
567 os = lang_output_section_find (tree->name.name);
570 if (expld.phase == lang_final_phase_enum)
571 einfo (_("%F%S: undefined section `%s' referenced in expression\n"),
574 else if (os->processed_vma)
575 new_rel (0, NULL, os->bfd_section);
580 if (expld.phase != lang_first_phase_enum)
582 lang_output_section_statement_type *os;
584 os = lang_output_section_find (tree->name.name);
587 if (expld.phase == lang_final_phase_enum)
588 einfo (_("%F%S: undefined section `%s' referenced in expression\n"),
591 else if (os->processed_lma)
593 if (os->load_base == NULL)
594 new_abs (os->bfd_section->lma);
597 exp_fold_tree_1 (os->load_base);
605 if (expld.phase != lang_first_phase_enum)
607 int opb = bfd_octets_per_byte (output_bfd);
608 lang_output_section_statement_type *os;
610 os = lang_output_section_find (tree->name.name);
613 if (expld.phase == lang_final_phase_enum)
614 einfo (_("%F%S: undefined section `%s' referenced in expression\n"),
618 else if (os->processed_vma)
619 new_abs (os->bfd_section->size / opb);
625 lang_memory_region_type *mem;
627 mem = lang_memory_region_lookup (tree->name.name, FALSE);
629 new_abs (mem->length);
631 einfo (_("%F%S: undefined MEMORY region `%s'"
632 " referenced in expression\n"), tree->name.name);
638 lang_memory_region_type *mem;
640 mem = lang_memory_region_lookup (tree->name.name, FALSE);
642 new_abs (mem->origin);
644 einfo (_("%F%S: undefined MEMORY region `%s'"
645 " referenced in expression\n"), tree->name.name);
650 if (strcmp (tree->name.name, "MAXPAGESIZE") == 0)
651 new_abs (bfd_emul_get_maxpagesize (default_target));
652 else if (strcmp (tree->name.name, "COMMONPAGESIZE") == 0)
653 new_abs (bfd_emul_get_commonpagesize (default_target));
655 einfo (_("%F%S: unknown constant `%s' referenced in expression\n"),
666 exp_fold_tree_1 (etree_type *tree)
670 memset (&expld.result, 0, sizeof (expld.result));
674 switch (tree->type.node_class)
677 new_rel (tree->value.value, tree->value.str, expld.section);
681 if (expld.phase != lang_first_phase_enum)
683 asection *output_section = tree->rel.section->output_section;
684 new_rel (tree->rel.value + tree->rel.section->output_offset,
685 NULL, output_section);
688 memset (&expld.result, 0, sizeof (expld.result));
692 exp_fold_tree_1 (tree->assert_s.child);
693 if (expld.phase == lang_final_phase_enum && !expld.result.value)
694 einfo ("%X%P: %s\n", tree->assert_s.message);
712 if (tree->assign.dst[0] == '.' && tree->assign.dst[1] == 0)
714 /* Assignment to dot can only be done during allocation. */
715 if (tree->type.node_class != etree_assign)
716 einfo (_("%F%S can not PROVIDE assignment to location counter\n"));
717 if (expld.phase == lang_mark_phase_enum
718 || expld.phase == lang_allocating_phase_enum
719 || (expld.phase == lang_final_phase_enum
720 && expld.section == bfd_abs_section_ptr))
722 /* Notify the folder that this is an assignment to dot. */
723 expld.assigning_to_dot = TRUE;
724 exp_fold_tree_1 (tree->assign.src);
725 expld.assigning_to_dot = FALSE;
727 if (!expld.result.valid_p)
729 if (expld.phase != lang_mark_phase_enum)
730 einfo (_("%F%S invalid assignment to location counter\n"));
732 else if (expld.dotp == NULL)
733 einfo (_("%F%S assignment to location counter"
734 " invalid outside of SECTION\n"));
739 nextdot = expld.result.value + expld.section->vma;
740 if (nextdot < expld.dot
741 && expld.section != bfd_abs_section_ptr)
742 einfo (_("%F%S cannot move location counter backwards"
743 " (from %V to %V)\n"), expld.dot, nextdot);
747 *expld.dotp = nextdot;
752 memset (&expld.result, 0, sizeof (expld.result));
756 struct bfd_link_hash_entry *h = NULL;
758 if (tree->type.node_class == etree_provide)
760 h = bfd_link_hash_lookup (link_info.hash, tree->assign.dst,
763 || (h->type != bfd_link_hash_new
764 && h->type != bfd_link_hash_undefined
765 && h->type != bfd_link_hash_common))
767 /* Do nothing. The symbol was never referenced, or was
768 defined by some object. */
773 exp_fold_tree_1 (tree->assign.src);
774 if (expld.result.valid_p)
778 h = bfd_link_hash_lookup (link_info.hash, tree->assign.dst,
781 einfo (_("%P%F:%s: hash creation failed\n"),
785 /* FIXME: Should we worry if the symbol is already
787 lang_update_definedness (tree->assign.dst, h);
788 h->type = bfd_link_hash_defined;
789 h->u.def.value = expld.result.value;
790 h->u.def.section = expld.result.section;
791 if (tree->type.node_class == etree_provide)
792 tree->type.node_class = etree_provided;
803 memset (&expld.result, 0, sizeof (expld.result));
809 exp_fold_tree (etree_type *tree, asection *current_section, bfd_vma *dotp)
813 expld.section = current_section;
814 exp_fold_tree_1 (tree);
818 exp_fold_tree_no_dot (etree_type *tree)
822 expld.section = bfd_abs_section_ptr;
823 exp_fold_tree_1 (tree);
827 exp_binop (int code, etree_type *lhs, etree_type *rhs)
829 etree_type value, *new;
831 value.type.node_code = code;
832 value.binary.lhs = lhs;
833 value.binary.rhs = rhs;
834 value.type.node_class = etree_binary;
835 exp_fold_tree_no_dot (&value);
836 if (expld.result.valid_p)
837 return exp_intop (expld.result.value);
839 new = stat_alloc (sizeof (new->binary));
840 memcpy (new, &value, sizeof (new->binary));
845 exp_trinop (int code, etree_type *cond, etree_type *lhs, etree_type *rhs)
847 etree_type value, *new;
849 value.type.node_code = code;
850 value.trinary.lhs = lhs;
851 value.trinary.cond = cond;
852 value.trinary.rhs = rhs;
853 value.type.node_class = etree_trinary;
854 exp_fold_tree_no_dot (&value);
855 if (expld.result.valid_p)
856 return exp_intop (expld.result.value);
858 new = stat_alloc (sizeof (new->trinary));
859 memcpy (new, &value, sizeof (new->trinary));
864 exp_unop (int code, etree_type *child)
866 etree_type value, *new;
868 value.unary.type.node_code = code;
869 value.unary.child = child;
870 value.unary.type.node_class = etree_unary;
871 exp_fold_tree_no_dot (&value);
872 if (expld.result.valid_p)
873 return exp_intop (expld.result.value);
875 new = stat_alloc (sizeof (new->unary));
876 memcpy (new, &value, sizeof (new->unary));
881 exp_nameop (int code, const char *name)
883 etree_type value, *new;
885 value.name.type.node_code = code;
886 value.name.name = name;
887 value.name.type.node_class = etree_name;
889 exp_fold_tree_no_dot (&value);
890 if (expld.result.valid_p)
891 return exp_intop (expld.result.value);
893 new = stat_alloc (sizeof (new->name));
894 memcpy (new, &value, sizeof (new->name));
900 exp_assop (int code, const char *dst, etree_type *src)
904 new = stat_alloc (sizeof (new->assign));
905 new->type.node_code = code;
906 new->type.node_class = etree_assign;
907 new->assign.src = src;
908 new->assign.dst = dst;
912 /* Handle PROVIDE. */
915 exp_provide (const char *dst, etree_type *src, bfd_boolean hidden)
919 n = stat_alloc (sizeof (n->assign));
920 n->assign.type.node_code = '=';
921 n->assign.type.node_class = etree_provide;
924 n->assign.hidden = hidden;
931 exp_assert (etree_type *exp, const char *message)
935 n = stat_alloc (sizeof (n->assert_s));
936 n->assert_s.type.node_code = '!';
937 n->assert_s.type.node_class = etree_assert;
938 n->assert_s.child = exp;
939 n->assert_s.message = message;
944 exp_print_tree (etree_type *tree)
946 if (config.map_file == NULL)
947 config.map_file = stderr;
951 minfo ("NULL TREE\n");
955 switch (tree->type.node_class)
958 minfo ("0x%v", tree->value.value);
961 if (tree->rel.section->owner != NULL)
962 minfo ("%B:", tree->rel.section->owner);
963 minfo ("%s+0x%v", tree->rel.section->name, tree->rel.value);
966 fprintf (config.map_file, "%s", tree->assign.dst);
967 exp_print_token (tree->type.node_code, TRUE);
968 exp_print_tree (tree->assign.src);
972 fprintf (config.map_file, "PROVIDE (%s, ", tree->assign.dst);
973 exp_print_tree (tree->assign.src);
974 fprintf (config.map_file, ")");
977 fprintf (config.map_file, "(");
978 exp_print_tree (tree->binary.lhs);
979 exp_print_token (tree->type.node_code, TRUE);
980 exp_print_tree (tree->binary.rhs);
981 fprintf (config.map_file, ")");
984 exp_print_tree (tree->trinary.cond);
985 fprintf (config.map_file, "?");
986 exp_print_tree (tree->trinary.lhs);
987 fprintf (config.map_file, ":");
988 exp_print_tree (tree->trinary.rhs);
991 exp_print_token (tree->unary.type.node_code, FALSE);
992 if (tree->unary.child)
994 fprintf (config.map_file, " (");
995 exp_print_tree (tree->unary.child);
996 fprintf (config.map_file, ")");
1001 fprintf (config.map_file, "ASSERT (");
1002 exp_print_tree (tree->assert_s.child);
1003 fprintf (config.map_file, ", %s)", tree->assert_s.message);
1007 if (tree->type.node_code == NAME)
1009 fprintf (config.map_file, "%s", tree->name.name);
1013 exp_print_token (tree->type.node_code, FALSE);
1014 if (tree->name.name)
1015 fprintf (config.map_file, " (%s)", tree->name.name);
1025 exp_get_vma (etree_type *tree, bfd_vma def, char *name)
1029 exp_fold_tree_no_dot (tree);
1030 if (expld.result.valid_p)
1031 return expld.result.value;
1032 else if (name != NULL && expld.phase != lang_mark_phase_enum)
1033 einfo (_("%F%S nonconstant expression for %s\n"), name);
1039 exp_get_value_int (etree_type *tree, int def, char *name)
1041 return exp_get_vma (tree, def, name);
1045 exp_get_fill (etree_type *tree, fill_type *def, char *name)
1054 exp_fold_tree_no_dot (tree);
1055 if (!expld.result.valid_p)
1057 if (name != NULL && expld.phase != lang_mark_phase_enum)
1058 einfo (_("%F%S nonconstant expression for %s\n"), name);
1062 if (expld.result.str != NULL && (len = strlen (expld.result.str)) != 0)
1066 fill = xmalloc ((len + 1) / 2 + sizeof (*fill) - 1);
1067 fill->size = (len + 1) / 2;
1069 s = (unsigned char *) expld.result.str;
1077 digit = (digit - 'A' + '0' + 10) & 0xf;
1091 fill = xmalloc (4 + sizeof (*fill) - 1);
1092 val = expld.result.value;
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, int def, char *name)
1107 exp_fold_tree_no_dot (tree);
1109 if (expld.result.valid_p)
1111 expld.result.value += expld.result.section->vma;
1112 return expld.result.value;
1114 else if (name != NULL && expld.phase != lang_mark_phase_enum)
1115 einfo (_("%F%S nonconstant expression for %s\n"), name);
1121 align_n (bfd_vma value, bfd_vma align)
1126 value = (value + align - 1) / align;
1127 return value * align;