Evaluate __start_* and __stop_* symbol PROVIDE expressions early
[external/binutils.git] / ld / ldexp.c
1 /* This module handles expression trees.
2    Copyright (C) 1991-2015 Free Software Foundation, Inc.
3    Written by Steve Chamberlain of Cygnus Support <sac@cygnus.com>.
4
5    This file is part of the GNU Binutils.
6
7    This program is free software; you can redistribute it and/or modify
8    it under the terms of the GNU General Public License as published by
9    the Free Software Foundation; either version 3 of the License, or
10    (at your option) any later version.
11
12    This program is distributed in the hope that it will be useful,
13    but WITHOUT ANY WARRANTY; without even the implied warranty of
14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15    GNU General Public License for more details.
16
17    You should have received a copy of the GNU General Public License
18    along with this program; if not, write to the Free Software
19    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20    MA 02110-1301, USA.  */
21
22
23 /* This module is in charge of working out the contents of expressions.
24
25    It has to keep track of the relative/absness of a symbol etc. This
26    is done by keeping all values in a struct (an etree_value_type)
27    which contains a value, a section to which it is relative and a
28    valid bit.  */
29
30 #include "sysdep.h"
31 #include "bfd.h"
32 #include "bfdlink.h"
33
34 #include "ld.h"
35 #include "ldmain.h"
36 #include "ldmisc.h"
37 #include "ldexp.h"
38 #include "ldlex.h"
39 #include <ldgram.h>
40 #include "ldlang.h"
41 #include "libiberty.h"
42 #include "safe-ctype.h"
43
44 static void exp_fold_tree_1 (etree_type *);
45 static bfd_vma align_n (bfd_vma, bfd_vma);
46
47 segment_type *segments;
48
49 struct ldexp_control expld;
50
51 /* This structure records symbols for which we need to keep track of
52    definedness for use in the DEFINED () test.  It is also used in
53    making absolute symbols section relative late in the link.   */
54
55 struct definedness_hash_entry
56 {
57   struct bfd_hash_entry root;
58
59   /* If this symbol was assigned from "dot" outside of an output
60      section statement, the section we'd like it relative to.  */
61   asection *final_sec;
62
63   /* Symbol was defined by an object file.  */
64   unsigned int by_object : 1;
65
66   /* Symbols was defined by a script.  */
67   unsigned int by_script : 1;
68
69   /* Low bit of iteration count.  Symbols with matching iteration have
70      been defined in this pass over the script.  */
71   unsigned int iteration : 1;
72 };
73
74 static struct bfd_hash_table definedness_table;
75
76 /* Print the string representation of the given token.  Surround it
77    with spaces if INFIX_P is TRUE.  */
78
79 static void
80 exp_print_token (token_code_type code, int infix_p)
81 {
82   static const struct
83   {
84     token_code_type code;
85     const char * name;
86   }
87   table[] =
88   {
89     { INT, "int" },
90     { NAME, "NAME" },
91     { PLUSEQ, "+=" },
92     { MINUSEQ, "-=" },
93     { MULTEQ, "*=" },
94     { DIVEQ, "/=" },
95     { LSHIFTEQ, "<<=" },
96     { RSHIFTEQ, ">>=" },
97     { ANDEQ, "&=" },
98     { OREQ, "|=" },
99     { OROR, "||" },
100     { ANDAND, "&&" },
101     { EQ, "==" },
102     { NE, "!=" },
103     { LE, "<=" },
104     { GE, ">=" },
105     { LSHIFT, "<<" },
106     { RSHIFT, ">>" },
107     { LOG2CEIL, "LOG2CEIL" },
108     { ALIGN_K, "ALIGN" },
109     { BLOCK, "BLOCK" },
110     { QUAD, "QUAD" },
111     { SQUAD, "SQUAD" },
112     { LONG, "LONG" },
113     { SHORT, "SHORT" },
114     { BYTE, "BYTE" },
115     { SECTIONS, "SECTIONS" },
116     { SIZEOF_HEADERS, "SIZEOF_HEADERS" },
117     { MEMORY, "MEMORY" },
118     { DEFINED, "DEFINED" },
119     { TARGET_K, "TARGET" },
120     { SEARCH_DIR, "SEARCH_DIR" },
121     { MAP, "MAP" },
122     { ENTRY, "ENTRY" },
123     { NEXT, "NEXT" },
124     { ALIGNOF, "ALIGNOF" },
125     { SIZEOF, "SIZEOF" },
126     { ADDR, "ADDR" },
127     { LOADADDR, "LOADADDR" },
128     { CONSTANT, "CONSTANT" },
129     { ABSOLUTE, "ABSOLUTE" },
130     { MAX_K, "MAX" },
131     { MIN_K, "MIN" },
132     { ASSERT_K, "ASSERT" },
133     { REL, "relocatable" },
134     { DATA_SEGMENT_ALIGN, "DATA_SEGMENT_ALIGN" },
135     { DATA_SEGMENT_RELRO_END, "DATA_SEGMENT_RELRO_END" },
136     { DATA_SEGMENT_END, "DATA_SEGMENT_END" },
137     { ORIGIN, "ORIGIN" },
138     { LENGTH, "LENGTH" },
139     { SEGMENT_START, "SEGMENT_START" }
140   };
141   unsigned int idx;
142
143   for (idx = 0; idx < ARRAY_SIZE (table); idx++)
144     if (table[idx].code == code)
145       break;
146
147   if (infix_p)
148     fputc (' ', config.map_file);
149
150   if (idx < ARRAY_SIZE (table))
151     fputs (table[idx].name, config.map_file);
152   else if (code < 127)
153     fputc (code, config.map_file);
154   else
155     fprintf (config.map_file, "<code %d>", code);
156
157   if (infix_p)
158     fputc (' ', config.map_file);
159 }
160
161 static void
162 make_log2ceil (void)
163 {
164   bfd_vma value = expld.result.value;
165   bfd_vma result = -1;
166   bfd_boolean round_up = FALSE;
167
168   do
169     {
170       result++;
171       /* If more than one bit is set in the value we will need to round up.  */
172       if ((value > 1) && (value & 1))
173         round_up = TRUE;
174     }
175   while (value >>= 1);
176
177   if (round_up)
178     result += 1;
179   expld.result.section = NULL;
180   expld.result.value = result;
181 }
182
183 static void
184 make_abs (void)
185 {
186   if (expld.result.section != NULL)
187     expld.result.value += expld.result.section->vma;
188   expld.result.section = bfd_abs_section_ptr;
189   expld.rel_from_abs = FALSE;
190 }
191
192 static void
193 new_abs (bfd_vma value)
194 {
195   expld.result.valid_p = TRUE;
196   expld.result.section = bfd_abs_section_ptr;
197   expld.result.value = value;
198   expld.result.str = NULL;
199 }
200
201 etree_type *
202 exp_intop (bfd_vma value)
203 {
204   etree_type *new_e = (etree_type *) stat_alloc (sizeof (new_e->value));
205   new_e->type.node_code = INT;
206   new_e->type.filename = ldlex_filename ();
207   new_e->type.lineno = lineno;
208   new_e->value.value = value;
209   new_e->value.str = NULL;
210   new_e->type.node_class = etree_value;
211   return new_e;
212 }
213
214 etree_type *
215 exp_bigintop (bfd_vma value, char *str)
216 {
217   etree_type *new_e = (etree_type *) stat_alloc (sizeof (new_e->value));
218   new_e->type.node_code = INT;
219   new_e->type.filename = ldlex_filename ();
220   new_e->type.lineno = lineno;
221   new_e->value.value = value;
222   new_e->value.str = str;
223   new_e->type.node_class = etree_value;
224   return new_e;
225 }
226
227 /* Build an expression representing an unnamed relocatable value.  */
228
229 etree_type *
230 exp_relop (asection *section, bfd_vma value)
231 {
232   etree_type *new_e = (etree_type *) stat_alloc (sizeof (new_e->rel));
233   new_e->type.node_code = REL;
234   new_e->type.filename = ldlex_filename ();
235   new_e->type.lineno = lineno;
236   new_e->type.node_class = etree_rel;
237   new_e->rel.section = section;
238   new_e->rel.value = value;
239   return new_e;
240 }
241
242 static void
243 new_number (bfd_vma value)
244 {
245   expld.result.valid_p = TRUE;
246   expld.result.value = value;
247   expld.result.str = NULL;
248   expld.result.section = NULL;
249 }
250
251 static void
252 new_rel (bfd_vma value, asection *section)
253 {
254   expld.result.valid_p = TRUE;
255   expld.result.value = value;
256   expld.result.str = NULL;
257   expld.result.section = section;
258 }
259
260 static void
261 new_rel_from_abs (bfd_vma value)
262 {
263   asection *s = expld.section;
264
265   expld.rel_from_abs = TRUE;
266   expld.result.valid_p = TRUE;
267   expld.result.value = value - s->vma;
268   expld.result.str = NULL;
269   expld.result.section = s;
270 }
271
272 /* New-function for the definedness hash table.  */
273
274 static struct bfd_hash_entry *
275 definedness_newfunc (struct bfd_hash_entry *entry,
276                      struct bfd_hash_table *table ATTRIBUTE_UNUSED,
277                      const char *name ATTRIBUTE_UNUSED)
278 {
279   struct definedness_hash_entry *ret = (struct definedness_hash_entry *) entry;
280
281   if (ret == NULL)
282     ret = (struct definedness_hash_entry *)
283       bfd_hash_allocate (table, sizeof (struct definedness_hash_entry));
284
285   if (ret == NULL)
286     einfo (_("%P%F: bfd_hash_allocate failed creating symbol %s\n"), name);
287
288   ret->by_object = 0;
289   ret->by_script = 0;
290   ret->iteration = 0;
291   return &ret->root;
292 }
293
294 /* Called during processing of linker script script expressions.
295    For symbols assigned in a linker script, return a struct describing
296    where the symbol is defined relative to the current expression,
297    otherwise return NULL.  */
298
299 static struct definedness_hash_entry *
300 symbol_defined (const char *name)
301 {
302   return ((struct definedness_hash_entry *)
303           bfd_hash_lookup (&definedness_table, name, FALSE, FALSE));
304 }
305
306 /* Update the definedness state of NAME.  Return FALSE if script symbol
307    is multiply defining a strong symbol in an object.  */
308
309 static bfd_boolean
310 update_definedness (const char *name, struct bfd_link_hash_entry *h)
311 {
312   bfd_boolean ret;
313   struct definedness_hash_entry *defentry
314     = (struct definedness_hash_entry *)
315     bfd_hash_lookup (&definedness_table, name, TRUE, FALSE);
316
317   if (defentry == NULL)
318     einfo (_("%P%F: bfd_hash_lookup failed creating symbol %s\n"), name);
319
320   /* If the symbol was already defined, and not by a script, then it
321      must be defined by an object file or by the linker target code.  */
322   ret = TRUE;
323   if (!defentry->by_script
324       && (h->type == bfd_link_hash_defined
325           || h->type == bfd_link_hash_defweak
326           || h->type == bfd_link_hash_common))
327     {
328       defentry->by_object = 1;
329       if (h->type == bfd_link_hash_defined
330           && h->u.def.section->output_section != NULL
331           && !h->linker_def)
332         ret = FALSE;
333     }
334
335   defentry->by_script = 1;
336   defentry->iteration = lang_statement_iteration;
337   defentry->final_sec = bfd_abs_section_ptr;
338   if (expld.phase == lang_final_phase_enum
339       && expld.rel_from_abs
340       && expld.result.section == bfd_abs_section_ptr)
341     defentry->final_sec = section_for_dot ();
342   return ret;
343 }
344
345 static void
346 fold_unary (etree_type *tree)
347 {
348   exp_fold_tree_1 (tree->unary.child);
349   if (expld.result.valid_p)
350     {
351       switch (tree->type.node_code)
352         {
353         case ALIGN_K:
354           if (expld.phase != lang_first_phase_enum)
355             new_rel_from_abs (align_n (expld.dot, expld.result.value));
356           else
357             expld.result.valid_p = FALSE;
358           break;
359
360         case ABSOLUTE:
361           make_abs ();
362           break;
363
364         case LOG2CEIL:
365           make_log2ceil ();
366           break;
367
368         case '~':
369           expld.result.value = ~expld.result.value;
370           break;
371
372         case '!':
373           expld.result.value = !expld.result.value;
374           break;
375
376         case '-':
377           expld.result.value = -expld.result.value;
378           break;
379
380         case NEXT:
381           /* Return next place aligned to value.  */
382           if (expld.phase != lang_first_phase_enum)
383             {
384               make_abs ();
385               expld.result.value = align_n (expld.dot, expld.result.value);
386             }
387           else
388             expld.result.valid_p = FALSE;
389           break;
390
391         case DATA_SEGMENT_END:
392           if (expld.phase == lang_first_phase_enum
393               || expld.section != bfd_abs_section_ptr)
394             {
395               expld.result.valid_p = FALSE;
396             }
397           else if (expld.dataseg.phase == exp_dataseg_align_seen
398                    || expld.dataseg.phase == exp_dataseg_relro_seen)
399             {
400               expld.dataseg.phase = exp_dataseg_end_seen;
401               expld.dataseg.end = expld.result.value;
402             }
403           else if (expld.dataseg.phase == exp_dataseg_done
404                    || expld.dataseg.phase == exp_dataseg_adjust
405                    || expld.dataseg.phase == exp_dataseg_relro_adjust)
406             {
407               /* OK.  */
408             }
409           else
410             expld.result.valid_p = FALSE;
411           break;
412
413         default:
414           FAIL ();
415           break;
416         }
417     }
418 }
419
420 static void
421 fold_binary (etree_type *tree)
422 {
423   etree_value_type lhs;
424   exp_fold_tree_1 (tree->binary.lhs);
425
426   /* The SEGMENT_START operator is special because its first
427      operand is a string, not the name of a symbol.  Note that the
428      operands have been swapped, so binary.lhs is second (default)
429      operand, binary.rhs is first operand.  */
430   if (expld.result.valid_p && tree->type.node_code == SEGMENT_START)
431     {
432       const char *segment_name;
433       segment_type *seg;
434
435       /* Check to see if the user has overridden the default
436          value.  */
437       segment_name = tree->binary.rhs->name.name;
438       for (seg = segments; seg; seg = seg->next)
439         if (strcmp (seg->name, segment_name) == 0)
440           {
441             if (!seg->used
442                 && config.magic_demand_paged
443                 && (seg->value % config.maxpagesize) != 0)
444               einfo (_("%P: warning: address of `%s' isn't multiple of maximum page size\n"),
445                      segment_name);
446             seg->used = TRUE;
447             new_rel_from_abs (seg->value);
448             break;
449           }
450       return;
451     }
452
453   lhs = expld.result;
454   exp_fold_tree_1 (tree->binary.rhs);
455   expld.result.valid_p &= lhs.valid_p;
456
457   if (expld.result.valid_p)
458     {
459       if (lhs.section != expld.result.section)
460         {
461           /* If the values are from different sections, and neither is
462              just a number, make both the source arguments absolute.  */
463           if (expld.result.section != NULL
464               && lhs.section != NULL)
465             {
466               make_abs ();
467               lhs.value += lhs.section->vma;
468               lhs.section = bfd_abs_section_ptr;
469             }
470
471           /* If the rhs is just a number, keep the lhs section.  */
472           else if (expld.result.section == NULL)
473             {
474               expld.result.section = lhs.section;
475               /* Make this NULL so that we know one of the operands
476                  was just a number, for later tests.  */
477               lhs.section = NULL;
478             }
479         }
480       /* At this point we know that both operands have the same
481          section, or at least one of them is a plain number.  */
482
483       switch (tree->type.node_code)
484         {
485           /* Arithmetic operators, bitwise AND, bitwise OR and XOR
486              keep the section of one of their operands only when the
487              other operand is a plain number.  Losing the section when
488              operating on two symbols, ie. a result of a plain number,
489              is required for subtraction and XOR.  It's justifiable
490              for the other operations on the grounds that adding,
491              multiplying etc. two section relative values does not
492              really make sense unless they are just treated as
493              numbers.
494              The same argument could be made for many expressions
495              involving one symbol and a number.  For example,
496              "1 << x" and "100 / x" probably should not be given the
497              section of x.  The trouble is that if we fuss about such
498              things the rules become complex and it is onerous to
499              document ld expression evaluation.  */
500 #define BOP(x, y) \
501         case x:                                                 \
502           expld.result.value = lhs.value y expld.result.value;  \
503           if (expld.result.section == lhs.section)              \
504             expld.result.section = NULL;                        \
505           break;
506
507           /* Comparison operators, logical AND, and logical OR always
508              return a plain number.  */
509 #define BOPN(x, y) \
510         case x:                                                 \
511           expld.result.value = lhs.value y expld.result.value;  \
512           expld.result.section = NULL;                          \
513           break;
514
515           BOP ('+', +);
516           BOP ('*', *);
517           BOP ('-', -);
518           BOP (LSHIFT, <<);
519           BOP (RSHIFT, >>);
520           BOP ('&', &);
521           BOP ('^', ^);
522           BOP ('|', |);
523           BOPN (EQ, ==);
524           BOPN (NE, !=);
525           BOPN ('<', <);
526           BOPN ('>', >);
527           BOPN (LE, <=);
528           BOPN (GE, >=);
529           BOPN (ANDAND, &&);
530           BOPN (OROR, ||);
531
532         case '%':
533           if (expld.result.value != 0)
534             expld.result.value = ((bfd_signed_vma) lhs.value
535                                   % (bfd_signed_vma) expld.result.value);
536           else if (expld.phase != lang_mark_phase_enum)
537             einfo (_("%F%S %% by zero\n"), tree->binary.rhs);
538           if (expld.result.section == lhs.section)
539             expld.result.section = NULL;
540           break;
541
542         case '/':
543           if (expld.result.value != 0)
544             expld.result.value = ((bfd_signed_vma) lhs.value
545                                   / (bfd_signed_vma) expld.result.value);
546           else if (expld.phase != lang_mark_phase_enum)
547             einfo (_("%F%S / by zero\n"), tree->binary.rhs);
548           if (expld.result.section == lhs.section)
549             expld.result.section = NULL;
550           break;
551
552         case MAX_K:
553           if (lhs.value > expld.result.value)
554             expld.result.value = lhs.value;
555           break;
556
557         case MIN_K:
558           if (lhs.value < expld.result.value)
559             expld.result.value = lhs.value;
560           break;
561
562         case ALIGN_K:
563           expld.result.value = align_n (lhs.value, expld.result.value);
564           break;
565
566         case DATA_SEGMENT_ALIGN:
567           expld.dataseg.relro = exp_dataseg_relro_start;
568           if (expld.phase == lang_first_phase_enum
569               || expld.section != bfd_abs_section_ptr)
570             expld.result.valid_p = FALSE;
571           else
572             {
573               bfd_vma maxpage = lhs.value;
574               bfd_vma commonpage = expld.result.value;
575
576               expld.result.value = align_n (expld.dot, maxpage);
577               if (expld.dataseg.phase == exp_dataseg_relro_adjust)
578                 expld.result.value = expld.dataseg.base;
579               else if (expld.dataseg.phase == exp_dataseg_adjust)
580                 {
581                   if (commonpage < maxpage)
582                     expld.result.value += ((expld.dot + commonpage - 1)
583                                            & (maxpage - commonpage));
584                 }
585               else
586                 {
587                   expld.result.value += expld.dot & (maxpage - 1);
588                   if (expld.dataseg.phase == exp_dataseg_done)
589                     {
590                       /* OK.  */
591                     }
592                   else if (expld.dataseg.phase == exp_dataseg_none)
593                     {
594                       expld.dataseg.phase = exp_dataseg_align_seen;
595                       expld.dataseg.base = expld.result.value;
596                       expld.dataseg.pagesize = commonpage;
597                       expld.dataseg.maxpagesize = maxpage;
598                       expld.dataseg.relro_end = 0;
599                     }
600                   else
601                     expld.result.valid_p = FALSE;
602                 }
603             }
604           break;
605
606         case DATA_SEGMENT_RELRO_END:
607           /* Operands swapped!  DATA_SEGMENT_RELRO_END(offset,exp)
608              has offset in expld.result and exp in lhs.  */
609           expld.dataseg.relro = exp_dataseg_relro_end;
610           expld.dataseg.relro_offset = expld.result.value;
611           if (expld.phase == lang_first_phase_enum
612               || expld.section != bfd_abs_section_ptr)
613             expld.result.valid_p = FALSE;
614           else if (expld.dataseg.phase == exp_dataseg_align_seen
615                    || expld.dataseg.phase == exp_dataseg_adjust
616                    || expld.dataseg.phase == exp_dataseg_relro_adjust
617                    || expld.dataseg.phase == exp_dataseg_done)
618             {
619               if (expld.dataseg.phase == exp_dataseg_align_seen
620                   || expld.dataseg.phase == exp_dataseg_relro_adjust)
621                 expld.dataseg.relro_end = lhs.value + expld.result.value;
622
623               if (expld.dataseg.phase == exp_dataseg_relro_adjust
624                   && (expld.dataseg.relro_end
625                       & (expld.dataseg.pagesize - 1)))
626                 {
627                   expld.dataseg.relro_end += expld.dataseg.pagesize - 1;
628                   expld.dataseg.relro_end &= ~(expld.dataseg.pagesize - 1);
629                   expld.result.value = (expld.dataseg.relro_end
630                                         - expld.result.value);
631                 }
632               else
633                 expld.result.value = lhs.value;
634
635               if (expld.dataseg.phase == exp_dataseg_align_seen)
636                 expld.dataseg.phase = exp_dataseg_relro_seen;
637             }
638           else
639             expld.result.valid_p = FALSE;
640           break;
641
642         default:
643           FAIL ();
644         }
645     }
646 }
647
648 static void
649 fold_trinary (etree_type *tree)
650 {
651   exp_fold_tree_1 (tree->trinary.cond);
652   if (expld.result.valid_p)
653     exp_fold_tree_1 (expld.result.value
654                      ? tree->trinary.lhs
655                      : tree->trinary.rhs);
656 }
657
658 static void
659 fold_name (etree_type *tree)
660 {
661   memset (&expld.result, 0, sizeof (expld.result));
662
663   switch (tree->type.node_code)
664     {
665     case SIZEOF_HEADERS:
666       if (expld.phase != lang_first_phase_enum)
667         {
668           bfd_vma hdr_size = 0;
669           /* Don't find the real header size if only marking sections;
670              The bfd function may cache incorrect data.  */
671           if (expld.phase != lang_mark_phase_enum)
672             hdr_size = bfd_sizeof_headers (link_info.output_bfd, &link_info);
673           new_number (hdr_size);
674         }
675       break;
676
677     case DEFINED:
678       if (expld.phase != lang_first_phase_enum)
679         {
680           struct bfd_link_hash_entry *h;
681           struct definedness_hash_entry *def;
682
683           h = bfd_wrapped_link_hash_lookup (link_info.output_bfd,
684                                             &link_info,
685                                             tree->name.name,
686                                             FALSE, FALSE, TRUE);
687           new_number (h != NULL
688                       && (h->type == bfd_link_hash_defined
689                           || h->type == bfd_link_hash_defweak
690                           || h->type == bfd_link_hash_common)
691                       && ((def = symbol_defined (tree->name.name)) == NULL
692                           || def->by_object
693                           || def->iteration == (lang_statement_iteration & 1)));
694         }
695       break;
696
697     case NAME:
698       if (expld.assign_name != NULL
699           && strcmp (expld.assign_name, tree->name.name) == 0)
700         {
701           /* Self-assignment is only allowed for absolute symbols
702              defined in a linker script.  */
703           struct bfd_link_hash_entry *h;
704           struct definedness_hash_entry *def;
705
706           h = bfd_wrapped_link_hash_lookup (link_info.output_bfd,
707                                             &link_info,
708                                             tree->name.name,
709                                             FALSE, FALSE, TRUE);
710           if (!(h != NULL
711                 && (h->type == bfd_link_hash_defined
712                     || h->type == bfd_link_hash_defweak)
713                 && h->u.def.section == bfd_abs_section_ptr
714                 && (def = symbol_defined (tree->name.name)) != NULL
715                 && def->iteration == (lang_statement_iteration & 1)))
716             expld.assign_name = NULL;
717         }
718       if (expld.phase == lang_first_phase_enum)
719         ;
720       else if (tree->name.name[0] == '.' && tree->name.name[1] == 0)
721         new_rel_from_abs (expld.dot);
722       else
723         {
724           struct bfd_link_hash_entry *h;
725
726           h = bfd_wrapped_link_hash_lookup (link_info.output_bfd,
727                                             &link_info,
728                                             tree->name.name,
729                                             TRUE, FALSE, TRUE);
730           if (!h)
731             einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
732           else if (h->type == bfd_link_hash_defined
733                    || h->type == bfd_link_hash_defweak)
734             {
735               asection *output_section;
736
737               output_section = h->u.def.section->output_section;
738               if (output_section == NULL)
739                 {
740                   if (expld.phase == lang_mark_phase_enum)
741                     new_rel (h->u.def.value, h->u.def.section);
742                   else
743                     einfo (_("%X%S: unresolvable symbol `%s'"
744                              " referenced in expression\n"),
745                            tree, tree->name.name);
746                 }
747               else if (output_section == bfd_abs_section_ptr
748                        && (expld.section != bfd_abs_section_ptr
749                            || config.sane_expr))
750                 new_number (h->u.def.value + h->u.def.section->output_offset);
751               else
752                 new_rel (h->u.def.value + h->u.def.section->output_offset,
753                          output_section);
754             }
755           else if (expld.phase == lang_final_phase_enum
756                    || (expld.phase != lang_mark_phase_enum
757                        && expld.assigning_to_dot))
758             einfo (_("%F%S: undefined symbol `%s'"
759                      " referenced in expression\n"),
760                    tree, tree->name.name);
761           else if (h->type == bfd_link_hash_new)
762             {
763               h->type = bfd_link_hash_undefined;
764               h->u.undef.abfd = NULL;
765               if (h->u.undef.next == NULL && h != link_info.hash->undefs_tail)
766                 bfd_link_add_undef (link_info.hash, h);
767             }
768         }
769       break;
770
771     case ADDR:
772       if (expld.phase != lang_first_phase_enum)
773         {
774           lang_output_section_statement_type *os;
775
776           os = lang_output_section_find (tree->name.name);
777           if (os == NULL)
778             {
779               if (expld.phase == lang_final_phase_enum)
780                 einfo (_("%F%S: undefined section `%s'"
781                          " referenced in expression\n"),
782                        tree, tree->name.name);
783             }
784           else if (os->processed_vma)
785             new_rel (0, os->bfd_section);
786         }
787       break;
788
789     case LOADADDR:
790       if (expld.phase != lang_first_phase_enum)
791         {
792           lang_output_section_statement_type *os;
793
794           os = lang_output_section_find (tree->name.name);
795           if (os == NULL)
796             {
797               if (expld.phase == lang_final_phase_enum)
798                 einfo (_("%F%S: undefined section `%s'"
799                          " referenced in expression\n"),
800                        tree, tree->name.name);
801             }
802           else if (os->processed_lma)
803             {
804               if (os->load_base == NULL)
805                 new_abs (os->bfd_section->lma);
806               else
807                 {
808                   exp_fold_tree_1 (os->load_base);
809                   if (expld.result.valid_p)
810                     make_abs ();
811                 }
812             }
813         }
814       break;
815
816     case SIZEOF:
817     case ALIGNOF:
818       if (expld.phase != lang_first_phase_enum)
819         {
820           lang_output_section_statement_type *os;
821
822           os = lang_output_section_find (tree->name.name);
823           if (os == NULL)
824             {
825               if (expld.phase == lang_final_phase_enum)
826                 einfo (_("%F%S: undefined section `%s'"
827                          " referenced in expression\n"),
828                        tree, tree->name.name);
829               new_number (0);
830             }
831           else if (os->bfd_section != NULL)
832             {
833               bfd_vma val;
834
835               if (tree->type.node_code == SIZEOF)
836                 val = (os->bfd_section->size
837                        / bfd_octets_per_byte (link_info.output_bfd));
838               else
839                 val = (bfd_vma)1 << os->bfd_section->alignment_power;
840
841               new_number (val);
842             }
843           else
844             new_number (0);
845         }
846       break;
847
848     case LENGTH:
849       {
850       if (expld.phase != lang_first_phase_enum)
851         {
852           lang_memory_region_type *mem;
853
854           mem = lang_memory_region_lookup (tree->name.name, FALSE);
855           if (mem != NULL)
856             new_number (mem->length);
857           else
858             einfo (_("%F%S: undefined MEMORY region `%s'"
859              " referenced in expression\n"),
860            tree, tree->name.name);
861         }
862       }
863       break;
864
865     case ORIGIN:
866       if (expld.phase != lang_first_phase_enum)
867         {
868           lang_memory_region_type *mem;
869
870           mem = lang_memory_region_lookup (tree->name.name, FALSE);
871           if (mem != NULL)
872             new_rel_from_abs (mem->origin);
873           else
874             einfo (_("%F%S: undefined MEMORY region `%s'"
875                      " referenced in expression\n"),
876                    tree, tree->name.name);
877         }
878       break;
879
880     case CONSTANT:
881       if (strcmp (tree->name.name, "MAXPAGESIZE") == 0)
882         new_number (config.maxpagesize);
883       else if (strcmp (tree->name.name, "COMMONPAGESIZE") == 0)
884         new_number (config.commonpagesize);
885       else
886         einfo (_("%F%S: unknown constant `%s' referenced in expression\n"),
887                tree, tree->name.name);
888       break;
889
890     default:
891       FAIL ();
892       break;
893     }
894 }
895
896 /* Return true if TREE is '.'.  */
897
898 static bfd_boolean
899 is_dot (const etree_type *tree)
900 {
901   return (tree->type.node_class == etree_name
902           && tree->type.node_code == NAME
903           && tree->name.name[0] == '.'
904           && tree->name.name[1] == 0);
905 }
906
907 /* Return true if TREE is a constant equal to VAL.  */
908
909 static bfd_boolean
910 is_value (const etree_type *tree, bfd_vma val)
911 {
912   return (tree->type.node_class == etree_value
913           && tree->value.value == val);
914 }
915
916 /* Return true if TREE is an absolute symbol equal to VAL defined in
917    a linker script.  */
918
919 static bfd_boolean
920 is_sym_value (const etree_type *tree, bfd_vma val)
921 {
922   struct bfd_link_hash_entry *h;
923   struct definedness_hash_entry *def;
924
925   return (tree->type.node_class == etree_name
926           && tree->type.node_code == NAME
927           && (def = symbol_defined (tree->name.name)) != NULL
928           && def->by_script
929           && def->iteration == (lang_statement_iteration & 1)
930           && (h = bfd_wrapped_link_hash_lookup (link_info.output_bfd,
931                                                 &link_info,
932                                                 tree->name.name,
933                                                 FALSE, FALSE, TRUE)) != NULL
934           && h->type == bfd_link_hash_defined
935           && h->u.def.section == bfd_abs_section_ptr
936           && h->u.def.value == val);
937 }
938
939 /* Return true if TREE is ". != 0".  */
940
941 static bfd_boolean
942 is_dot_ne_0 (const etree_type *tree)
943 {
944   return (tree->type.node_class == etree_binary
945           && tree->type.node_code == NE
946           && is_dot (tree->binary.lhs)
947           && is_value (tree->binary.rhs, 0));
948 }
949
950 /* Return true if TREE is ". = . + 0" or ". = . + sym" where sym is an
951    absolute constant with value 0 defined in a linker script.  */
952
953 static bfd_boolean
954 is_dot_plus_0 (const etree_type *tree)
955 {
956   return (tree->type.node_class == etree_binary
957           && tree->type.node_code == '+'
958           && is_dot (tree->binary.lhs)
959           && (is_value (tree->binary.rhs, 0)
960               || is_sym_value (tree->binary.rhs, 0)));
961 }
962
963 /* Return true if TREE is "ALIGN (. != 0 ? some_expression : 1)".  */
964
965 static bfd_boolean
966 is_align_conditional (const etree_type *tree)
967 {
968   if (tree->type.node_class == etree_unary
969       && tree->type.node_code == ALIGN_K)
970     {
971       tree = tree->unary.child;
972       return (tree->type.node_class == etree_trinary
973               && is_dot_ne_0 (tree->trinary.cond)
974               && is_value (tree->trinary.rhs, 1));
975     }
976   return FALSE;
977 }
978
979 /* Subroutine of exp_fold_tree_1 for copying a symbol type.  */
980
981 static void
982 try_copy_symbol_type (struct bfd_link_hash_entry * h, etree_type *src)
983 {
984   if (src->type.node_class == etree_name)
985     {
986       struct bfd_link_hash_entry *hsrc;
987
988       hsrc = bfd_link_hash_lookup (link_info.hash, src->name.name,
989                                     FALSE, FALSE, TRUE);
990       if (hsrc)
991         bfd_copy_link_hash_symbol_type (link_info.output_bfd, h,
992                                                     hsrc);
993     }
994 }
995
996 static void
997 exp_fold_tree_1 (etree_type *tree)
998 {
999   if (tree == NULL)
1000     {
1001       memset (&expld.result, 0, sizeof (expld.result));
1002       return;
1003     }
1004
1005   switch (tree->type.node_class)
1006     {
1007     case etree_value:
1008       if (expld.section == bfd_abs_section_ptr
1009           && !config.sane_expr)
1010         new_abs (tree->value.value);
1011       else
1012         new_number (tree->value.value);
1013       expld.result.str = tree->value.str;
1014       break;
1015
1016     case etree_rel:
1017       if (expld.phase != lang_first_phase_enum)
1018         {
1019           asection *output_section = tree->rel.section->output_section;
1020           new_rel (tree->rel.value + tree->rel.section->output_offset,
1021                    output_section);
1022         }
1023       else
1024         memset (&expld.result, 0, sizeof (expld.result));
1025       break;
1026
1027     case etree_assert:
1028       exp_fold_tree_1 (tree->assert_s.child);
1029       if (expld.phase == lang_final_phase_enum && !expld.result.value)
1030         einfo ("%X%P: %s\n", tree->assert_s.message);
1031       break;
1032
1033     case etree_unary:
1034       fold_unary (tree);
1035       break;
1036
1037     case etree_binary:
1038       fold_binary (tree);
1039       break;
1040
1041     case etree_trinary:
1042       fold_trinary (tree);
1043       break;
1044
1045     case etree_assign:
1046     case etree_provide:
1047     case etree_provided:
1048       if (tree->assign.dst[0] == '.' && tree->assign.dst[1] == 0)
1049         {
1050           if (tree->type.node_class != etree_assign)
1051             einfo (_("%F%S can not PROVIDE assignment to"
1052                      " location counter\n"), tree);
1053           if (expld.phase != lang_first_phase_enum)
1054             {
1055               /* Notify the folder that this is an assignment to dot.  */
1056               expld.assigning_to_dot = TRUE;
1057               exp_fold_tree_1 (tree->assign.src);
1058               expld.assigning_to_dot = FALSE;
1059
1060               /* If we are assigning to dot inside an output section
1061                  arrange to keep the section, except for certain
1062                  expressions that evaluate to zero.  We ignore . = 0,
1063                  . = . + 0, and . = ALIGN (. != 0 ? expr : 1).
1064                  We can't ignore all expressions that evaluate to zero
1065                  because an otherwise empty section might have padding
1066                  added by an alignment expression that changes with
1067                  relaxation.  Such a section might have zero size
1068                  before relaxation and so be stripped incorrectly.  */
1069               if (expld.phase == lang_mark_phase_enum
1070                   && expld.section != bfd_abs_section_ptr
1071                   && !(expld.result.valid_p
1072                        && expld.result.value == 0
1073                        && (is_value (tree->assign.src, 0)
1074                            || is_sym_value (tree->assign.src, 0)
1075                            || is_dot_plus_0 (tree->assign.src)
1076                            || is_align_conditional (tree->assign.src))))
1077                 expld.section->flags |= SEC_KEEP;
1078
1079               if (!expld.result.valid_p)
1080                 {
1081                   if (expld.phase != lang_mark_phase_enum)
1082                     einfo (_("%F%S invalid assignment to"
1083                              " location counter\n"), tree);
1084                 }
1085               else if (expld.dotp == NULL)
1086                 einfo (_("%F%S assignment to location counter"
1087                          " invalid outside of SECTIONS\n"), tree);
1088
1089               /* After allocation, assignment to dot should not be
1090                  done inside an output section since allocation adds a
1091                  padding statement that effectively duplicates the
1092                  assignment.  */
1093               else if (expld.phase <= lang_allocating_phase_enum
1094                        || expld.section == bfd_abs_section_ptr)
1095                 {
1096                   bfd_vma nextdot;
1097
1098                   nextdot = expld.result.value;
1099                   if (expld.result.section != NULL)
1100                     nextdot += expld.result.section->vma;
1101                   else
1102                     nextdot += expld.section->vma;
1103                   if (nextdot < expld.dot
1104                       && expld.section != bfd_abs_section_ptr)
1105                     einfo (_("%F%S cannot move location counter backwards"
1106                              " (from %V to %V)\n"),
1107                            tree, expld.dot, nextdot);
1108                   else
1109                     {
1110                       expld.dot = nextdot;
1111                       *expld.dotp = nextdot;
1112                     }
1113                 }
1114             }
1115           else
1116             memset (&expld.result, 0, sizeof (expld.result));
1117         }
1118       else
1119         {
1120           struct bfd_link_hash_entry *h = NULL;
1121
1122           if (tree->type.node_class == etree_provide)
1123             {
1124               h = bfd_link_hash_lookup (link_info.hash, tree->assign.dst,
1125                                         FALSE, FALSE, TRUE);
1126               if (h == NULL
1127                   || !(h->type == bfd_link_hash_new
1128                        || h->type == bfd_link_hash_undefined
1129                        || h->type == bfd_link_hash_undefweak
1130                        || h->linker_def))
1131                 {
1132                   /* Do nothing.  The symbol was never referenced, or
1133                      was defined in some object file.  Note that
1134                      undefweak symbols are defined by PROVIDE.  This
1135                      is to support glibc use of __rela_iplt_start and
1136                      similar weak references.  */
1137                   break;
1138                 }
1139             }
1140
1141           expld.assign_name = tree->assign.dst;
1142           exp_fold_tree_1 (tree->assign.src);
1143           /* expld.assign_name remaining equal to tree->assign.dst
1144              below indicates the evaluation of tree->assign.src did
1145              not use the value of tree->assign.dst.  We don't allow
1146              self assignment until the final phase for two reasons:
1147              1) Expressions are evaluated multiple times.  With
1148              relaxation, the number of times may vary.
1149              2) Section relative symbol values cannot be correctly
1150              converted to absolute values, as is required by many
1151              expressions, until final section sizing is complete.  */
1152           if ((expld.result.valid_p
1153                && (expld.phase == lang_final_phase_enum
1154                    || expld.assign_name != NULL))
1155               || (expld.phase <= lang_mark_phase_enum
1156                   && tree->type.node_class == etree_assign
1157                   && tree->assign.defsym))
1158             {
1159               if (h == NULL)
1160                 {
1161                   h = bfd_link_hash_lookup (link_info.hash, tree->assign.dst,
1162                                             TRUE, FALSE, TRUE);
1163                   if (h == NULL)
1164                     einfo (_("%P%F:%s: hash creation failed\n"),
1165                            tree->assign.dst);
1166                 }
1167
1168               if (expld.result.section == NULL)
1169                 expld.result.section = expld.section;
1170               if (!update_definedness (tree->assign.dst, h) && 0)
1171                 {
1172                   /* Symbol was already defined.  For now this error
1173                      is disabled because it causes failures in the ld
1174                      testsuite: ld-elf/var1, ld-scripts/defined5, and
1175                      ld-scripts/pr14962.  Some of these no doubt
1176                      reflect scripts used in the wild.  */
1177                   (*link_info.callbacks->multiple_definition)
1178                     (&link_info, h, link_info.output_bfd,
1179                      expld.result.section, expld.result.value);
1180                 }
1181               h->type = bfd_link_hash_defined;
1182               h->u.def.value = expld.result.value;
1183               h->u.def.section = expld.result.section;
1184               h->linker_def = 0;
1185               if (tree->type.node_class == etree_provide)
1186                 tree->type.node_class = etree_provided;
1187
1188               /* Copy the symbol type if this is a simple assignment of
1189                  one symbol to another.  Also, handle the case of a foldable
1190                  ternary conditional with names on either side.  */
1191               if (tree->assign.src->type.node_class == etree_name)
1192                 try_copy_symbol_type (h, tree->assign.src);
1193               else if (tree->assign.src->type.node_class == etree_trinary)
1194                 {
1195                   exp_fold_tree_1 (tree->assign.src->trinary.cond);
1196                   if (expld.result.valid_p)
1197                     {
1198                       if (expld.result.value
1199                           && tree->assign.src->trinary.lhs->type.node_class
1200                              == etree_name)
1201                         try_copy_symbol_type (h, tree->assign.src->trinary.lhs);
1202
1203                       if (!expld.result.value
1204                           && tree->assign.src->trinary.rhs->type.node_class
1205                              == etree_name)
1206                         try_copy_symbol_type (h, tree->assign.src->trinary.rhs);
1207                     }
1208                 }
1209             }
1210           else if (expld.phase == lang_final_phase_enum)
1211             {
1212               h = bfd_link_hash_lookup (link_info.hash, tree->assign.dst,
1213                                         FALSE, FALSE, TRUE);
1214               if (h != NULL
1215                   && h->type == bfd_link_hash_new)
1216                 h->type = bfd_link_hash_undefined;
1217             }
1218           expld.assign_name = NULL;
1219         }
1220       break;
1221
1222     case etree_name:
1223       fold_name (tree);
1224       break;
1225
1226     default:
1227       FAIL ();
1228       memset (&expld.result, 0, sizeof (expld.result));
1229       break;
1230     }
1231 }
1232
1233 void
1234 exp_fold_tree (etree_type *tree, asection *current_section, bfd_vma *dotp)
1235 {
1236   expld.rel_from_abs = FALSE;
1237   expld.dot = *dotp;
1238   expld.dotp = dotp;
1239   expld.section = current_section;
1240   exp_fold_tree_1 (tree);
1241 }
1242
1243 void
1244 exp_fold_tree_no_dot (etree_type *tree)
1245 {
1246   expld.rel_from_abs = FALSE;
1247   expld.dot = 0;
1248   expld.dotp = NULL;
1249   expld.section = bfd_abs_section_ptr;
1250   exp_fold_tree_1 (tree);
1251 }
1252
1253 etree_type *
1254 exp_binop (int code, etree_type *lhs, etree_type *rhs)
1255 {
1256   etree_type value, *new_e;
1257
1258   value.type.node_code = code;
1259   value.type.filename = lhs->type.filename;
1260   value.type.lineno = lhs->type.lineno;
1261   value.binary.lhs = lhs;
1262   value.binary.rhs = rhs;
1263   value.type.node_class = etree_binary;
1264   exp_fold_tree_no_dot (&value);
1265   if (expld.result.valid_p)
1266     return exp_intop (expld.result.value);
1267
1268   new_e = (etree_type *) stat_alloc (sizeof (new_e->binary));
1269   memcpy (new_e, &value, sizeof (new_e->binary));
1270   return new_e;
1271 }
1272
1273 etree_type *
1274 exp_trinop (int code, etree_type *cond, etree_type *lhs, etree_type *rhs)
1275 {
1276   etree_type value, *new_e;
1277
1278   value.type.node_code = code;
1279   value.type.filename = cond->type.filename;
1280   value.type.lineno = cond->type.lineno;
1281   value.trinary.lhs = lhs;
1282   value.trinary.cond = cond;
1283   value.trinary.rhs = rhs;
1284   value.type.node_class = etree_trinary;
1285   exp_fold_tree_no_dot (&value);
1286   if (expld.result.valid_p)
1287     return exp_intop (expld.result.value);
1288
1289   new_e = (etree_type *) stat_alloc (sizeof (new_e->trinary));
1290   memcpy (new_e, &value, sizeof (new_e->trinary));
1291   return new_e;
1292 }
1293
1294 etree_type *
1295 exp_unop (int code, etree_type *child)
1296 {
1297   etree_type value, *new_e;
1298
1299   value.unary.type.node_code = code;
1300   value.unary.type.filename = child->type.filename;
1301   value.unary.type.lineno = child->type.lineno;
1302   value.unary.child = child;
1303   value.unary.type.node_class = etree_unary;
1304   exp_fold_tree_no_dot (&value);
1305   if (expld.result.valid_p)
1306     return exp_intop (expld.result.value);
1307
1308   new_e = (etree_type *) stat_alloc (sizeof (new_e->unary));
1309   memcpy (new_e, &value, sizeof (new_e->unary));
1310   return new_e;
1311 }
1312
1313 etree_type *
1314 exp_nameop (int code, const char *name)
1315 {
1316   etree_type value, *new_e;
1317
1318   value.name.type.node_code = code;
1319   value.name.type.filename = ldlex_filename ();
1320   value.name.type.lineno = lineno;
1321   value.name.name = name;
1322   value.name.type.node_class = etree_name;
1323
1324   exp_fold_tree_no_dot (&value);
1325   if (expld.result.valid_p)
1326     return exp_intop (expld.result.value);
1327
1328   new_e = (etree_type *) stat_alloc (sizeof (new_e->name));
1329   memcpy (new_e, &value, sizeof (new_e->name));
1330   return new_e;
1331
1332 }
1333
1334 static etree_type *
1335 exp_assop (const char *dst,
1336            etree_type *src,
1337            enum node_tree_enum class,
1338            bfd_boolean defsym,
1339            bfd_boolean hidden)
1340 {
1341   etree_type *n;
1342
1343   n = (etree_type *) stat_alloc (sizeof (n->assign));
1344   n->assign.type.node_code = '=';
1345   n->assign.type.filename = src->type.filename;
1346   n->assign.type.lineno = src->type.lineno;
1347   n->assign.type.node_class = class;
1348   n->assign.src = src;
1349   n->assign.dst = dst;
1350   n->assign.defsym = defsym;
1351   n->assign.hidden = hidden;
1352   return n;
1353 }
1354
1355 /* Handle linker script assignments and HIDDEN.  */
1356
1357 etree_type *
1358 exp_assign (const char *dst, etree_type *src, bfd_boolean hidden)
1359 {
1360   return exp_assop (dst, src, etree_assign, FALSE, hidden);
1361 }
1362
1363 /* Handle --defsym command-line option.  */
1364
1365 etree_type *
1366 exp_defsym (const char *dst, etree_type *src)
1367 {
1368   return exp_assop (dst, src, etree_assign, TRUE, FALSE);
1369 }
1370
1371 /* Handle PROVIDE.  */
1372
1373 etree_type *
1374 exp_provide (const char *dst, etree_type *src, bfd_boolean hidden)
1375 {
1376   return exp_assop (dst, src, etree_provide, FALSE, hidden);
1377 }
1378
1379 /* Handle ASSERT.  */
1380
1381 etree_type *
1382 exp_assert (etree_type *exp, const char *message)
1383 {
1384   etree_type *n;
1385
1386   n = (etree_type *) stat_alloc (sizeof (n->assert_s));
1387   n->assert_s.type.node_code = '!';
1388   n->assert_s.type.filename = exp->type.filename;
1389   n->assert_s.type.lineno = exp->type.lineno;
1390   n->assert_s.type.node_class = etree_assert;
1391   n->assert_s.child = exp;
1392   n->assert_s.message = message;
1393   return n;
1394 }
1395
1396 void
1397 exp_print_tree (etree_type *tree)
1398 {
1399   bfd_boolean function_like;
1400
1401   if (config.map_file == NULL)
1402     config.map_file = stderr;
1403
1404   if (tree == NULL)
1405     {
1406       minfo ("NULL TREE\n");
1407       return;
1408     }
1409
1410   switch (tree->type.node_class)
1411     {
1412     case etree_value:
1413       minfo ("0x%v", tree->value.value);
1414       return;
1415     case etree_rel:
1416       if (tree->rel.section->owner != NULL)
1417         minfo ("%B:", tree->rel.section->owner);
1418       minfo ("%s+0x%v", tree->rel.section->name, tree->rel.value);
1419       return;
1420     case etree_assign:
1421       fputs (tree->assign.dst, config.map_file);
1422       exp_print_token (tree->type.node_code, TRUE);
1423       exp_print_tree (tree->assign.src);
1424       break;
1425     case etree_provide:
1426     case etree_provided:
1427       fprintf (config.map_file, "PROVIDE (%s, ", tree->assign.dst);
1428       exp_print_tree (tree->assign.src);
1429       fputc (')', config.map_file);
1430       break;
1431     case etree_binary:
1432       function_like = FALSE;
1433       switch (tree->type.node_code)
1434         {
1435         case MAX_K:
1436         case MIN_K:
1437         case ALIGN_K:
1438         case DATA_SEGMENT_ALIGN:
1439         case DATA_SEGMENT_RELRO_END:
1440           function_like = TRUE;
1441           break;
1442         case SEGMENT_START:
1443           /* Special handling because arguments are in reverse order and
1444              the segment name is quoted.  */
1445           exp_print_token (tree->type.node_code, FALSE);
1446           fputs (" (\"", config.map_file);
1447           exp_print_tree (tree->binary.rhs);
1448           fputs ("\", ", config.map_file);
1449           exp_print_tree (tree->binary.lhs);
1450           fputc (')', config.map_file);
1451           return;
1452         }
1453       if (function_like)
1454         {
1455           exp_print_token (tree->type.node_code, FALSE);
1456           fputc (' ', config.map_file);
1457         }
1458       fputc ('(', config.map_file);
1459       exp_print_tree (tree->binary.lhs);
1460       if (function_like)
1461         fprintf (config.map_file, ", ");
1462       else
1463         exp_print_token (tree->type.node_code, TRUE);
1464       exp_print_tree (tree->binary.rhs);
1465       fputc (')', config.map_file);
1466       break;
1467     case etree_trinary:
1468       exp_print_tree (tree->trinary.cond);
1469       fputc ('?', config.map_file);
1470       exp_print_tree (tree->trinary.lhs);
1471       fputc (':', config.map_file);
1472       exp_print_tree (tree->trinary.rhs);
1473       break;
1474     case etree_unary:
1475       exp_print_token (tree->unary.type.node_code, FALSE);
1476       if (tree->unary.child)
1477         {
1478           fprintf (config.map_file, " (");
1479           exp_print_tree (tree->unary.child);
1480           fputc (')', config.map_file);
1481         }
1482       break;
1483
1484     case etree_assert:
1485       fprintf (config.map_file, "ASSERT (");
1486       exp_print_tree (tree->assert_s.child);
1487       fprintf (config.map_file, ", %s)", tree->assert_s.message);
1488       break;
1489
1490     case etree_name:
1491       if (tree->type.node_code == NAME)
1492         fputs (tree->name.name, config.map_file);
1493       else
1494         {
1495           exp_print_token (tree->type.node_code, FALSE);
1496           if (tree->name.name)
1497             fprintf (config.map_file, " (%s)", tree->name.name);
1498         }
1499       break;
1500     default:
1501       FAIL ();
1502       break;
1503     }
1504 }
1505
1506 bfd_vma
1507 exp_get_vma (etree_type *tree, bfd_vma def, char *name)
1508 {
1509   if (tree != NULL)
1510     {
1511       exp_fold_tree_no_dot (tree);
1512       if (expld.result.valid_p)
1513         return expld.result.value;
1514       else if (name != NULL && expld.phase != lang_mark_phase_enum)
1515         einfo (_("%F%S: nonconstant expression for %s\n"),
1516                tree, name);
1517     }
1518   return def;
1519 }
1520
1521 int
1522 exp_get_value_int (etree_type *tree, int def, char *name)
1523 {
1524   return exp_get_vma (tree, def, name);
1525 }
1526
1527 fill_type *
1528 exp_get_fill (etree_type *tree, fill_type *def, char *name)
1529 {
1530   fill_type *fill;
1531   size_t len;
1532   unsigned int val;
1533
1534   if (tree == NULL)
1535     return def;
1536
1537   exp_fold_tree_no_dot (tree);
1538   if (!expld.result.valid_p)
1539     {
1540       if (name != NULL && expld.phase != lang_mark_phase_enum)
1541         einfo (_("%F%S: nonconstant expression for %s\n"),
1542                tree, name);
1543       return def;
1544     }
1545
1546   if (expld.result.str != NULL && (len = strlen (expld.result.str)) != 0)
1547     {
1548       unsigned char *dst;
1549       unsigned char *s;
1550       fill = (fill_type *) xmalloc ((len + 1) / 2 + sizeof (*fill) - 1);
1551       fill->size = (len + 1) / 2;
1552       dst = fill->data;
1553       s = (unsigned char *) expld.result.str;
1554       val = 0;
1555       do
1556         {
1557           unsigned int digit;
1558
1559           digit = *s++ - '0';
1560           if (digit > 9)
1561             digit = (digit - 'A' + '0' + 10) & 0xf;
1562           val <<= 4;
1563           val += digit;
1564           --len;
1565           if ((len & 1) == 0)
1566             {
1567               *dst++ = val;
1568               val = 0;
1569             }
1570         }
1571       while (len != 0);
1572     }
1573   else
1574     {
1575       fill = (fill_type *) xmalloc (4 + sizeof (*fill) - 1);
1576       val = expld.result.value;
1577       fill->data[0] = (val >> 24) & 0xff;
1578       fill->data[1] = (val >> 16) & 0xff;
1579       fill->data[2] = (val >>  8) & 0xff;
1580       fill->data[3] = (val >>  0) & 0xff;
1581       fill->size = 4;
1582     }
1583   return fill;
1584 }
1585
1586 bfd_vma
1587 exp_get_abs_int (etree_type *tree, int def, char *name)
1588 {
1589   if (tree != NULL)
1590     {
1591       exp_fold_tree_no_dot (tree);
1592
1593       if (expld.result.valid_p)
1594         {
1595           if (expld.result.section != NULL)
1596             expld.result.value += expld.result.section->vma;
1597           return expld.result.value;
1598         }
1599       else if (name != NULL && expld.phase != lang_mark_phase_enum)
1600         {
1601           einfo (_("%F%S: nonconstant expression for %s\n"),
1602                  tree, name);
1603         }
1604     }
1605   return def;
1606 }
1607
1608 static bfd_vma
1609 align_n (bfd_vma value, bfd_vma align)
1610 {
1611   if (align <= 1)
1612     return value;
1613
1614   value = (value + align - 1) / align;
1615   return value * align;
1616 }
1617
1618 void
1619 ldexp_init (void)
1620 {
1621   /* The value "13" is ad-hoc, somewhat related to the expected number of
1622      assignments in a linker script.  */
1623   if (!bfd_hash_table_init_n (&definedness_table,
1624                               definedness_newfunc,
1625                               sizeof (struct definedness_hash_entry),
1626                               13))
1627     einfo (_("%P%F: can not create hash table: %E\n"));
1628 }
1629
1630 /* Convert absolute symbols defined by a script from "dot" (also
1631    SEGMENT_START or ORIGIN) outside of an output section statement,
1632    to section relative.  */
1633
1634 static bfd_boolean
1635 set_sym_sections (struct bfd_hash_entry *bh, void *inf ATTRIBUTE_UNUSED)
1636 {
1637   struct definedness_hash_entry *def = (struct definedness_hash_entry *) bh;
1638   if (def->final_sec != bfd_abs_section_ptr)
1639     {
1640       struct bfd_link_hash_entry *h;
1641       h = bfd_link_hash_lookup (link_info.hash, bh->string,
1642                                 FALSE, FALSE, TRUE);
1643       if (h != NULL
1644           && h->type == bfd_link_hash_defined
1645           && h->u.def.section == bfd_abs_section_ptr)
1646         {
1647           h->u.def.value -= def->final_sec->vma;
1648           h->u.def.section = def->final_sec;
1649         }
1650     }
1651   return TRUE;
1652 }
1653
1654 void
1655 ldexp_finalize_syms (void)
1656 {
1657   bfd_hash_traverse (&definedness_table, set_sym_sections, NULL);
1658 }
1659
1660 void
1661 ldexp_finish (void)
1662 {
1663   bfd_hash_table_free (&definedness_table);
1664 }