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