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 <[email protected]>.
   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 0;
 977 }
 978
 979 static void
 980 exp_fold_tree_1 (etree_type *tree)
 981 {
 982   if (tree == NULL)
 983     {
 984       memset (&expld.result, 0, sizeof (expld.result));
 985       return;
 986     }
 987
 988   switch (tree->type.node_class)
 989     {
 990     case etree_value:
 991       if (expld.section == bfd_abs_section_ptr
 992           && !config.sane_expr)
 993         new_abs (tree->value.value);
 994       else
 995         new_number (tree->value.value);
 996       expld.result.str = tree->value.str;
 997       break;
 998
 999     case etree_rel:
1000       if (expld.phase != lang_first_phase_enum)
1001         {
1002           asection *output_section = tree->rel.section->output_section;
1003           new_rel (tree->rel.value + tree->rel.section->output_offset,
1004                    output_section);
1005         }
1006       else
1007         memset (&expld.result, 0, sizeof (expld.result));
1008       break;
1009
1010     case etree_assert:
1011       exp_fold_tree_1 (tree->assert_s.child);
1012       if (expld.phase == lang_final_phase_enum && !expld.result.value)
1013         einfo ("%X%P: %s\n", tree->assert_s.message);
1014       break;
1015
1016     case etree_unary:
1017       fold_unary (tree);
1018       break;
1019
1020     case etree_binary:
1021       fold_binary (tree);
1022       break;
1023
1024     case etree_trinary:
1025       fold_trinary (tree);
1026       break;
1027
1028     case etree_assign:
1029     case etree_provide:
1030     case etree_provided:
1031       if (tree->assign.dst[0] == '.' && tree->assign.dst[1] == 0)
1032         {
1033           if (tree->type.node_class != etree_assign)
1034             einfo (_("%F%S can not PROVIDE assignment to"
1035                      " location counter\n"), tree);
1036           if (expld.phase != lang_first_phase_enum)
1037             {
1038               /* Notify the folder that this is an assignment to dot.  */
1039               expld.assigning_to_dot = TRUE;
1040               exp_fold_tree_1 (tree->assign.src);
1041               expld.assigning_to_dot = FALSE;
1042
1043               /* If we are assigning to dot inside an output section
1044                  arrange to keep the section, except for certain
1045                  expressions that evaluate to zero.  We ignore . = 0,
1046                  . = . + 0, and . = ALIGN (. != 0 ? expr : 1).
1047                  We can't ignore all expressions that evaluate to zero
1048                  because an otherwise empty section might have padding
1049                  added by an alignment expression that changes with
1050                  relaxation.  Such a section might have zero size
1051                  before relaxation and so be stripped incorrectly.  */
1052               if (expld.phase == lang_mark_phase_enum
1053                   && expld.section != bfd_abs_section_ptr
1054                   && !(expld.result.valid_p
1055                        && expld.result.value == 0
1056                        && (is_value (tree->assign.src, 0)
1057                            || is_sym_value (tree->assign.src, 0)
1058                            || is_dot_plus_0 (tree->assign.src)
1059                            || is_align_conditional (tree->assign.src))))
1060                 expld.section->flags |= SEC_KEEP;
1061
1062               if (!expld.result.valid_p)
1063                 {
1064                   if (expld.phase != lang_mark_phase_enum)
1065                     einfo (_("%F%S invalid assignment to"
1066                              " location counter\n"), tree);
1067                 }
1068               else if (expld.dotp == NULL)
1069                 einfo (_("%F%S assignment to location counter"
1070                          " invalid outside of SECTIONS\n"), tree);
1071
1072               /* After allocation, assignment to dot should not be
1073                  done inside an output section since allocation adds a
1074                  padding statement that effectively duplicates the
1075                  assignment.  */
1076               else if (expld.phase <= lang_allocating_phase_enum
1077                        || expld.section == bfd_abs_section_ptr)
1078                 {
1079                   bfd_vma nextdot;
1080
1081                   nextdot = expld.result.value;
1082                   if (expld.result.section != NULL)
1083                     nextdot += expld.result.section->vma;
1084                   else
1085                     nextdot += expld.section->vma;
1086                   if (nextdot < expld.dot
1087                       && expld.section != bfd_abs_section_ptr)
1088                     einfo (_("%F%S cannot move location counter backwards"
1089                              " (from %V to %V)\n"),
1090                            tree, expld.dot, nextdot);
1091                   else
1092                     {
1093                       expld.dot = nextdot;
1094                       *expld.dotp = nextdot;
1095                     }
1096                 }
1097             }
1098           else
1099             memset (&expld.result, 0, sizeof (expld.result));
1100         }
1101       else
1102         {
1103           struct bfd_link_hash_entry *h = NULL;
1104
1105           if (tree->type.node_class == etree_provide)
1106             {
1107               h = bfd_link_hash_lookup (link_info.hash, tree->assign.dst,
1108                                         FALSE, FALSE, TRUE);
1109               if (h == NULL
1110                   || !(h->type == bfd_link_hash_new
1111                        || h->type == bfd_link_hash_undefined
1112                        || h->linker_def))
1113                 {
1114                   /* Do nothing.  The symbol was never referenced, or
1115                      was defined in some object file.  Undefined weak
1116                      symbols stay undefined.  */
1117                   break;
1118                 }
1119             }
1120
1121           expld.assign_name = tree->assign.dst;
1122           exp_fold_tree_1 (tree->assign.src);
1123           /* expld.assign_name remaining equal to tree->assign.dst
1124              below indicates the evaluation of tree->assign.src did
1125              not use the value of tree->assign.dst.  We don't allow
1126              self assignment until the final phase for two reasons:
1127              1) Expressions are evaluated multiple times.  With
1128              relaxation, the number of times may vary.
1129              2) Section relative symbol values cannot be correctly
1130              converted to absolute values, as is required by many
1131              expressions, until final section sizing is complete.  */
1132           if ((expld.result.valid_p
1133                && (expld.phase == lang_final_phase_enum
1134                    || expld.assign_name != NULL))
1135               || (expld.phase <= lang_mark_phase_enum
1136                   && tree->type.node_class == etree_assign
1137                   && tree->assign.defsym))
1138             {
1139               if (h == NULL)
1140                 {
1141                   h = bfd_link_hash_lookup (link_info.hash, tree->assign.dst,
1142                                             TRUE, FALSE, TRUE);
1143                   if (h == NULL)
1144                     einfo (_("%P%F:%s: hash creation failed\n"),
1145                            tree->assign.dst);
1146                 }
1147
1148               if (expld.result.section == NULL)
1149                 expld.result.section = expld.section;
1150               if (!update_definedness (tree->assign.dst, h) && 0)
1151                 {
1152                   /* Symbol was already defined.  For now this error
1153                      is disabled because it causes failures in the ld
1154                      testsuite: ld-elf/var1, ld-scripts/defined5, and
1155                      ld-scripts/pr14962.  Some of these no doubt
1156                      reflect scripts used in the wild.  */
1157                   (*link_info.callbacks->multiple_definition)
1158                     (&link_info, h, link_info.output_bfd,
1159                      expld.result.section, expld.result.value);
1160                 }
1161               h->type = bfd_link_hash_defined;
1162               h->u.def.value = expld.result.value;
1163               h->u.def.section = expld.result.section;
1164               h->linker_def = 0;
1165               if (tree->type.node_class == etree_provide)
1166                 tree->type.node_class = etree_provided;
1167
1168               /* Copy the symbol type if this is a simple assignment of
1169                  one symbol to another.  This could be more general
1170                  (e.g. a ?: operator with NAMEs in each branch).  */
1171               if (tree->assign.src->type.node_class == etree_name)
1172                 {
1173                   struct bfd_link_hash_entry *hsrc;
1174
1175                   hsrc = bfd_link_hash_lookup (link_info.hash,
1176                                                tree->assign.src->name.name,
1177                                                FALSE, FALSE, TRUE);
1178                   if (hsrc)
1179                     bfd_copy_link_hash_symbol_type (link_info.output_bfd, h,
1180                                                     hsrc);
1181                 }
1182             }
1183           else if (expld.phase == lang_final_phase_enum)
1184             {
1185               h = bfd_link_hash_lookup (link_info.hash, tree->assign.dst,
1186                                         FALSE, FALSE, TRUE);
1187               if (h != NULL
1188                   && h->type == bfd_link_hash_new)
1189                 h->type = bfd_link_hash_undefined;
1190             }
1191           expld.assign_name = NULL;
1192         }
1193       break;
1194
1195     case etree_name:
1196       fold_name (tree);
1197       break;
1198
1199     default:
1200       FAIL ();
1201       memset (&expld.result, 0, sizeof (expld.result));
1202       break;
1203     }
1204 }
1205
1206 void
1207 exp_fold_tree (etree_type *tree, asection *current_section, bfd_vma *dotp)
1208 {
1209   expld.rel_from_abs = FALSE;
1210   expld.dot = *dotp;
1211   expld.dotp = dotp;
1212   expld.section = current_section;
1213   exp_fold_tree_1 (tree);
1214 }
1215
1216 void
1217 exp_fold_tree_no_dot (etree_type *tree)
1218 {
1219   expld.rel_from_abs = FALSE;
1220   expld.dot = 0;
1221   expld.dotp = NULL;
1222   expld.section = bfd_abs_section_ptr;
1223   exp_fold_tree_1 (tree);
1224 }
1225
1226 etree_type *
1227 exp_binop (int code, etree_type *lhs, etree_type *rhs)
1228 {
1229   etree_type value, *new_e;
1230
1231   value.type.node_code = code;
1232   value.type.filename = lhs->type.filename;
1233   value.type.lineno = lhs->type.lineno;
1234   value.binary.lhs = lhs;
1235   value.binary.rhs = rhs;
1236   value.type.node_class = etree_binary;
1237   exp_fold_tree_no_dot (&value);
1238   if (expld.result.valid_p)
1239     return exp_intop (expld.result.value);
1240
1241   new_e = (etree_type *) stat_alloc (sizeof (new_e->binary));
1242   memcpy (new_e, &value, sizeof (new_e->binary));
1243   return new_e;
1244 }
1245
1246 etree_type *
1247 exp_trinop (int code, etree_type *cond, etree_type *lhs, etree_type *rhs)
1248 {
1249   etree_type value, *new_e;
1250
1251   value.type.node_code = code;
1252   value.type.filename = cond->type.filename;
1253   value.type.lineno = cond->type.lineno;
1254   value.trinary.lhs = lhs;
1255   value.trinary.cond = cond;
1256   value.trinary.rhs = rhs;
1257   value.type.node_class = etree_trinary;
1258   exp_fold_tree_no_dot (&value);
1259   if (expld.result.valid_p)
1260     return exp_intop (expld.result.value);
1261
1262   new_e = (etree_type *) stat_alloc (sizeof (new_e->trinary));
1263   memcpy (new_e, &value, sizeof (new_e->trinary));
1264   return new_e;
1265 }
1266
1267 etree_type *
1268 exp_unop (int code, etree_type *child)
1269 {
1270   etree_type value, *new_e;
1271
1272   value.unary.type.node_code = code;
1273   value.unary.type.filename = child->type.filename;
1274   value.unary.type.lineno = child->type.lineno;
1275   value.unary.child = child;
1276   value.unary.type.node_class = etree_unary;
1277   exp_fold_tree_no_dot (&value);
1278   if (expld.result.valid_p)
1279     return exp_intop (expld.result.value);
1280
1281   new_e = (etree_type *) stat_alloc (sizeof (new_e->unary));
1282   memcpy (new_e, &value, sizeof (new_e->unary));
1283   return new_e;
1284 }
1285
1286 etree_type *
1287 exp_nameop (int code, const char *name)
1288 {
1289   etree_type value, *new_e;
1290
1291   value.name.type.node_code = code;
1292   value.name.type.filename = ldlex_filename ();
1293   value.name.type.lineno = lineno;
1294   value.name.name = name;
1295   value.name.type.node_class = etree_name;
1296
1297   exp_fold_tree_no_dot (&value);
1298   if (expld.result.valid_p)
1299     return exp_intop (expld.result.value);
1300
1301   new_e = (etree_type *) stat_alloc (sizeof (new_e->name));
1302   memcpy (new_e, &value, sizeof (new_e->name));
1303   return new_e;
1304
1305 }
1306
1307 static etree_type *
1308 exp_assop (const char *dst,
1309            etree_type *src,
1310            enum node_tree_enum class,
1311            bfd_boolean defsym,
1312            bfd_boolean hidden)
1313 {
1314   etree_type *n;
1315
1316   n = (etree_type *) stat_alloc (sizeof (n->assign));
1317   n->assign.type.node_code = '=';
1318   n->assign.type.filename = src->type.filename;
1319   n->assign.type.lineno = src->type.lineno;
1320   n->assign.type.node_class = class;
1321   n->assign.src = src;
1322   n->assign.dst = dst;
1323   n->assign.defsym = defsym;
1324   n->assign.hidden = hidden;
1325   return n;
1326 }
1327
1328 /* Handle linker script assignments and HIDDEN.  */
1329
1330 etree_type *
1331 exp_assign (const char *dst, etree_type *src, bfd_boolean hidden)
1332 {
1333   return exp_assop (dst, src, etree_assign, FALSE, hidden);
1334 }
1335
1336 /* Handle --defsym command-line option.  */
1337
1338 etree_type *
1339 exp_defsym (const char *dst, etree_type *src)
1340 {
1341   return exp_assop (dst, src, etree_assign, TRUE, FALSE);
1342 }
1343
1344 /* Handle PROVIDE.  */
1345
1346 etree_type *
1347 exp_provide (const char *dst, etree_type *src, bfd_boolean hidden)
1348 {
1349   return exp_assop (dst, src, etree_provide, FALSE, hidden);
1350 }
1351
1352 /* Handle ASSERT.  */
1353
1354 etree_type *
1355 exp_assert (etree_type *exp, const char *message)
1356 {
1357   etree_type *n;
1358
1359   n = (etree_type *) stat_alloc (sizeof (n->assert_s));
1360   n->assert_s.type.node_code = '!';
1361   n->assert_s.type.filename = exp->type.filename;
1362   n->assert_s.type.lineno = exp->type.lineno;
1363   n->assert_s.type.node_class = etree_assert;
1364   n->assert_s.child = exp;
1365   n->assert_s.message = message;
1366   return n;
1367 }
1368
1369 void
1370 exp_print_tree (etree_type *tree)
1371 {
1372   bfd_boolean function_like;
1373
1374   if (config.map_file == NULL)
1375     config.map_file = stderr;
1376
1377   if (tree == NULL)
1378     {
1379       minfo ("NULL TREE\n");
1380       return;
1381     }
1382
1383   switch (tree->type.node_class)
1384     {
1385     case etree_value:
1386       minfo ("0x%v", tree->value.value);
1387       return;
1388     case etree_rel:
1389       if (tree->rel.section->owner != NULL)
1390         minfo ("%B:", tree->rel.section->owner);
1391       minfo ("%s+0x%v", tree->rel.section->name, tree->rel.value);
1392       return;
1393     case etree_assign:
1394       fputs (tree->assign.dst, config.map_file);
1395       exp_print_token (tree->type.node_code, TRUE);
1396       exp_print_tree (tree->assign.src);
1397       break;
1398     case etree_provide:
1399     case etree_provided:
1400       fprintf (config.map_file, "PROVIDE (%s, ", tree->assign.dst);
1401       exp_print_tree (tree->assign.src);
1402       fputc (')', config.map_file);
1403       break;
1404     case etree_binary:
1405       function_like = FALSE;
1406       switch (tree->type.node_code)
1407         {
1408         case MAX_K:
1409         case MIN_K:
1410         case ALIGN_K:
1411         case DATA_SEGMENT_ALIGN:
1412         case DATA_SEGMENT_RELRO_END:
1413           function_like = TRUE;
1414           break;
1415         case SEGMENT_START:
1416           /* Special handling because arguments are in reverse order and
1417              the segment name is quoted.  */
1418           exp_print_token (tree->type.node_code, FALSE);
1419           fputs (" (\"", config.map_file);
1420           exp_print_tree (tree->binary.rhs);
1421           fputs ("\", ", config.map_file);
1422           exp_print_tree (tree->binary.lhs);
1423           fputc (')', config.map_file);
1424           return;
1425         }
1426       if (function_like)
1427         {
1428           exp_print_token (tree->type.node_code, FALSE);
1429           fputc (' ', config.map_file);
1430         }
1431       fputc ('(', config.map_file);
1432       exp_print_tree (tree->binary.lhs);
1433       if (function_like)
1434         fprintf (config.map_file, ", ");
1435       else
1436         exp_print_token (tree->type.node_code, TRUE);
1437       exp_print_tree (tree->binary.rhs);
1438       fputc (')', config.map_file);
1439       break;
1440     case etree_trinary:
1441       exp_print_tree (tree->trinary.cond);
1442       fputc ('?', config.map_file);
1443       exp_print_tree (tree->trinary.lhs);
1444       fputc (':', config.map_file);
1445       exp_print_tree (tree->trinary.rhs);
1446       break;
1447     case etree_unary:
1448       exp_print_token (tree->unary.type.node_code, FALSE);
1449       if (tree->unary.child)
1450         {
1451           fprintf (config.map_file, " (");
1452           exp_print_tree (tree->unary.child);
1453           fputc (')', config.map_file);
1454         }
1455       break;
1456
1457     case etree_assert:
1458       fprintf (config.map_file, "ASSERT (");
1459       exp_print_tree (tree->assert_s.child);
1460       fprintf (config.map_file, ", %s)", tree->assert_s.message);
1461       break;
1462
1463     case etree_name:
1464       if (tree->type.node_code == NAME)
1465         fputs (tree->name.name, config.map_file);
1466       else
1467         {
1468           exp_print_token (tree->type.node_code, FALSE);
1469           if (tree->name.name)
1470             fprintf (config.map_file, " (%s)", tree->name.name);
1471         }
1472       break;
1473     default:
1474       FAIL ();
1475       break;
1476     }
1477 }
1478
1479 bfd_vma
1480 exp_get_vma (etree_type *tree, bfd_vma def, char *name)
1481 {
1482   if (tree != NULL)
1483     {
1484       exp_fold_tree_no_dot (tree);
1485       if (expld.result.valid_p)
1486         return expld.result.value;
1487       else if (name != NULL && expld.phase != lang_mark_phase_enum)
1488         einfo (_("%F%S: nonconstant expression for %s\n"),
1489                tree, name);
1490     }
1491   return def;
1492 }
1493
1494 int
1495 exp_get_value_int (etree_type *tree, int def, char *name)
1496 {
1497   return exp_get_vma (tree, def, name);
1498 }
1499
1500 fill_type *
1501 exp_get_fill (etree_type *tree, fill_type *def, char *name)
1502 {
1503   fill_type *fill;
1504   size_t len;
1505   unsigned int val;
1506
1507   if (tree == NULL)
1508     return def;
1509
1510   exp_fold_tree_no_dot (tree);
1511   if (!expld.result.valid_p)
1512     {
1513       if (name != NULL && expld.phase != lang_mark_phase_enum)
1514         einfo (_("%F%S: nonconstant expression for %s\n"),
1515                tree, name);
1516       return def;
1517     }
1518
1519   if (expld.result.str != NULL && (len = strlen (expld.result.str)) != 0)
1520     {
1521       unsigned char *dst;
1522       unsigned char *s;
1523       fill = (fill_type *) xmalloc ((len + 1) / 2 + sizeof (*fill) - 1);
1524       fill->size = (len + 1) / 2;
1525       dst = fill->data;
1526       s = (unsigned char *) expld.result.str;
1527       val = 0;
1528       do
1529         {
1530           unsigned int digit;
1531
1532           digit = *s++ - '0';
1533           if (digit > 9)
1534             digit = (digit - 'A' + '0' + 10) & 0xf;
1535           val <<= 4;
1536           val += digit;
1537           --len;
1538           if ((len & 1) == 0)
1539             {
1540               *dst++ = val;
1541               val = 0;
1542             }
1543         }
1544       while (len != 0);
1545     }
1546   else
1547     {
1548       fill = (fill_type *) xmalloc (4 + sizeof (*fill) - 1);
1549       val = expld.result.value;
1550       fill->data[0] = (val >> 24) & 0xff;
1551       fill->data[1] = (val >> 16) & 0xff;
1552       fill->data[2] = (val >>  8) & 0xff;
1553       fill->data[3] = (val >>  0) & 0xff;
1554       fill->size = 4;
1555     }
1556   return fill;
1557 }
1558
1559 bfd_vma
1560 exp_get_abs_int (etree_type *tree, int def, char *name)
1561 {
1562   if (tree != NULL)
1563     {
1564       exp_fold_tree_no_dot (tree);
1565
1566       if (expld.result.valid_p)
1567         {
1568           if (expld.result.section != NULL)
1569             expld.result.value += expld.result.section->vma;
1570           return expld.result.value;
1571         }
1572       else if (name != NULL && expld.phase != lang_mark_phase_enum)
1573         {
1574           einfo (_("%F%S: nonconstant expression for %s\n"),
1575                  tree, name);
1576         }
1577     }
1578   return def;
1579 }
1580
1581 static bfd_vma
1582 align_n (bfd_vma value, bfd_vma align)
1583 {
1584   if (align <= 1)
1585     return value;
1586
1587   value = (value + align - 1) / align;
1588   return value * align;
1589 }
1590
1591 void
1592 ldexp_init (void)
1593 {
1594   /* The value "13" is ad-hoc, somewhat related to the expected number of
1595      assignments in a linker script.  */
1596   if (!bfd_hash_table_init_n (&definedness_table,
1597                               definedness_newfunc,
1598                               sizeof (struct definedness_hash_entry),
1599                               13))
1600     einfo (_("%P%F: can not create hash table: %E\n"));
1601 }
1602
1603 /* Convert absolute symbols defined by a script from "dot" (also
1604    SEGMENT_START or ORIGIN) outside of an output section statement,
1605    to section relative.  */
1606
1607 static bfd_boolean
1608 set_sym_sections (struct bfd_hash_entry *bh, void *inf ATTRIBUTE_UNUSED)
1609 {
1610   struct definedness_hash_entry *def = (struct definedness_hash_entry *) bh;
1611   if (def->final_sec != bfd_abs_section_ptr)
1612     {
1613       struct bfd_link_hash_entry *h;
1614       h = bfd_link_hash_lookup (link_info.hash, bh->string,
1615                                 FALSE, FALSE, TRUE);
1616       if (h != NULL
1617           && h->type == bfd_link_hash_defined
1618           && h->u.def.section == bfd_abs_section_ptr)
1619         {
1620           h->u.def.value -= def->final_sec->vma;
1621           h->u.def.section = def->final_sec;
1622         }
1623     }
1624   return TRUE;
1625 }
1626
1627 void
1628 ldexp_finalize_syms (void)
1629 {
1630   bfd_hash_traverse (&definedness_table, set_sym_sections, NULL);
1631 }
1632
1633 void
1634 ldexp_finish (void)
1635 {
1636   bfd_hash_table_free (&definedness_table);
1637 }