ld/ldexp.c

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