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 static void
 261 align_dot_val (bfd_vma align)
 262 {
 263   bfd_vma base = expld.section->vma;
 264
 265   new_rel_from_abs (base + align_n (expld.dot - base, align));
 266 }
 267
 268 /* New-function for the definedness hash table.  */
 269
 270 static struct bfd_hash_entry *
 271 definedness_newfunc (struct bfd_hash_entry *entry,
 272                      struct bfd_hash_table *table ATTRIBUTE_UNUSED,
 273                      const char *name ATTRIBUTE_UNUSED)
 274 {
 275   struct definedness_hash_entry *ret = (struct definedness_hash_entry *) entry;
 276
 277   if (ret == NULL)
 278     ret = (struct definedness_hash_entry *)
 279       bfd_hash_allocate (table, sizeof (struct definedness_hash_entry));
 280
 281   if (ret == NULL)
 282     einfo (_("%P%F: bfd_hash_allocate failed creating symbol %s\n"), name);
 283
 284   ret->by_object = 0;
 285   ret->by_script = 0;
 286   ret->iteration = 0;
 287   return &ret->root;
 288 }
 289
 290 /* Called during processing of linker script script expressions.
 291    For symbols assigned in a linker script, return a struct describing
 292    where the symbol is defined relative to the current expression,
 293    otherwise return NULL.  */
 294
 295 static struct definedness_hash_entry *
 296 symbol_defined (const char *name)
 297 {
 298   return ((struct definedness_hash_entry *)
 299           bfd_hash_lookup (&definedness_table, name, FALSE, FALSE));
 300 }
 301
 302 /* Update the definedness state of NAME.  Return FALSE if script symbol
 303    is multiply defining a strong symbol in an object.  */
 304
 305 static bfd_boolean
 306 update_definedness (const char *name, struct bfd_link_hash_entry *h)
 307 {
 308   bfd_boolean ret;
 309   struct definedness_hash_entry *defentry
 310     = (struct definedness_hash_entry *)
 311     bfd_hash_lookup (&definedness_table, name, TRUE, FALSE);
 312
 313   if (defentry == NULL)
 314     einfo (_("%P%F: bfd_hash_lookup failed creating symbol %s\n"), name);
 315
 316   /* If the symbol was already defined, and not by a script, then it
 317      must be defined by an object file or by the linker target code.  */
 318   ret = TRUE;
 319   if (!defentry->by_script
 320       && (h->type == bfd_link_hash_defined
 321           || h->type == bfd_link_hash_defweak
 322           || h->type == bfd_link_hash_common))
 323     {
 324       defentry->by_object = 1;
 325       if (h->type == bfd_link_hash_defined
 326           && h->u.def.section->output_section != NULL
 327           && !h->linker_def)
 328         ret = FALSE;
 329     }
 330
 331   defentry->by_script = 1;
 332   defentry->iteration = lang_statement_iteration;
 333   return ret;
 334 }
 335
 336 static void
 337 fold_unary (etree_type *tree)
 338 {
 339   exp_fold_tree_1 (tree->unary.child);
 340   if (expld.result.valid_p)
 341     {
 342       switch (tree->type.node_code)
 343         {
 344         case ALIGN_K:
 345           if (expld.phase != lang_first_phase_enum)
 346             align_dot_val (expld.result.value);
 347           else
 348             expld.result.valid_p = FALSE;
 349           break;
 350
 351         case ABSOLUTE:
 352           make_abs ();
 353           break;
 354
 355         case LOG2CEIL:
 356           make_log2ceil ();
 357           break;
 358
 359         case '~':
 360           expld.result.value = ~expld.result.value;
 361           break;
 362
 363         case '!':
 364           expld.result.value = !expld.result.value;
 365           break;
 366
 367         case '-':
 368           expld.result.value = -expld.result.value;
 369           break;
 370
 371         case NEXT:
 372           /* Return next place aligned to value.  */
 373           if (expld.phase != lang_first_phase_enum)
 374             {
 375               make_abs ();
 376               align_dot_val (expld.result.value);
 377             }
 378           else
 379             expld.result.valid_p = FALSE;
 380           break;
 381
 382         case DATA_SEGMENT_END:
 383           if (expld.phase == lang_first_phase_enum
 384               || expld.section != bfd_abs_section_ptr)
 385             {
 386               expld.result.valid_p = FALSE;
 387             }
 388           else if (expld.dataseg.phase == exp_dataseg_align_seen
 389                    || expld.dataseg.phase == exp_dataseg_relro_seen)
 390             {
 391               expld.dataseg.phase = exp_dataseg_end_seen;
 392               expld.dataseg.end = expld.result.value;
 393             }
 394           else if (expld.dataseg.phase == exp_dataseg_done
 395                    || expld.dataseg.phase == exp_dataseg_adjust
 396                    || expld.dataseg.phase == exp_dataseg_relro_adjust)
 397             {
 398               /* OK.  */
 399             }
 400           else
 401             expld.result.valid_p = FALSE;
 402           break;
 403
 404         default:
 405           FAIL ();
 406           break;
 407         }
 408     }
 409 }
 410
 411 static void
 412 fold_binary (etree_type *tree)
 413 {
 414   etree_value_type lhs;
 415   exp_fold_tree_1 (tree->binary.lhs);
 416
 417   /* The SEGMENT_START operator is special because its first
 418      operand is a string, not the name of a symbol.  Note that the
 419      operands have been swapped, so binary.lhs is second (default)
 420      operand, binary.rhs is first operand.  */
 421   if (expld.result.valid_p && tree->type.node_code == SEGMENT_START)
 422     {
 423       const char *segment_name;
 424       segment_type *seg;
 425
 426       /* Check to see if the user has overridden the default
 427          value.  */
 428       segment_name = tree->binary.rhs->name.name;
 429       for (seg = segments; seg; seg = seg->next)
 430         if (strcmp (seg->name, segment_name) == 0)
 431           {
 432             if (!seg->used
 433                 && config.magic_demand_paged
 434                 && (seg->value % config.maxpagesize) != 0)
 435               einfo (_("%P: warning: address of `%s' isn't multiple of maximum page size\n"),
 436                      segment_name);
 437             seg->used = TRUE;
 438             new_rel_from_abs (seg->value);
 439             break;
 440           }
 441       return;
 442     }
 443
 444   lhs = expld.result;
 445   exp_fold_tree_1 (tree->binary.rhs);
 446   expld.result.valid_p &= lhs.valid_p;
 447
 448   if (expld.result.valid_p)
 449     {
 450       if (lhs.section != expld.result.section)
 451         {
 452           /* If the values are from different sections, and neither is
 453              just a number, make both the source arguments absolute.  */
 454           if (expld.result.section != NULL
 455               && lhs.section != NULL)
 456             {
 457               make_abs ();
 458               lhs.value += lhs.section->vma;
 459               lhs.section = bfd_abs_section_ptr;
 460             }
 461
 462           /* If the rhs is just a number, keep the lhs section.  */
 463           else if (expld.result.section == NULL)
 464             {
 465               expld.result.section = lhs.section;
 466               /* Make this NULL so that we know one of the operands
 467                  was just a number, for later tests.  */
 468               lhs.section = NULL;
 469             }
 470         }
 471       /* At this point we know that both operands have the same
 472          section, or at least one of them is a plain number.  */
 473
 474       switch (tree->type.node_code)
 475         {
 476           /* Arithmetic operators, bitwise AND, bitwise OR and XOR
 477              keep the section of one of their operands only when the
 478              other operand is a plain number.  Losing the section when
 479              operating on two symbols, ie. a result of a plain number,
 480              is required for subtraction and XOR.  It's justifiable
 481              for the other operations on the grounds that adding,
 482              multiplying etc. two section relative values does not
 483              really make sense unless they are just treated as
 484              numbers.
 485              The same argument could be made for many expressions
 486              involving one symbol and a number.  For example,
 487              "1 << x" and "100 / x" probably should not be given the
 488              section of x.  The trouble is that if we fuss about such
 489              things the rules become complex and it is onerous to
 490              document ld expression evaluation.  */
 491 #define BOP(x, y) \
 492         case x:                                                 \
 493           expld.result.value = lhs.value y expld.result.value;  \
 494           if (expld.result.section == lhs.section)              \
 495             expld.result.section = NULL;                        \
 496           break;
 497
 498           /* Comparison operators, logical AND, and logical OR always
 499              return a plain number.  */
 500 #define BOPN(x, y) \
 501         case x:                                                 \
 502           expld.result.value = lhs.value y expld.result.value;  \
 503           expld.result.section = NULL;                          \
 504           break;
 505
 506           BOP ('+', +);
 507           BOP ('*', *);
 508           BOP ('-', -);
 509           BOP (LSHIFT, <<);
 510           BOP (RSHIFT, >>);
 511           BOP ('&', &);
 512           BOP ('^', ^);
 513           BOP ('|', |);
 514           BOPN (EQ, ==);
 515           BOPN (NE, !=);
 516           BOPN ('<', <);
 517           BOPN ('>', >);
 518           BOPN (LE, <=);
 519           BOPN (GE, >=);
 520           BOPN (ANDAND, &&);
 521           BOPN (OROR, ||);
 522
 523         case '%':
 524           if (expld.result.value != 0)
 525             expld.result.value = ((bfd_signed_vma) lhs.value
 526                                   % (bfd_signed_vma) expld.result.value);
 527           else if (expld.phase != lang_mark_phase_enum)
 528             einfo (_("%F%S %% by zero\n"), tree->binary.rhs);
 529           if (expld.result.section == lhs.section)
 530             expld.result.section = NULL;
 531           break;
 532
 533         case '/':
 534           if (expld.result.value != 0)
 535             expld.result.value = ((bfd_signed_vma) lhs.value
 536                                   / (bfd_signed_vma) expld.result.value);
 537           else if (expld.phase != lang_mark_phase_enum)
 538             einfo (_("%F%S / by zero\n"), tree->binary.rhs);
 539           if (expld.result.section == lhs.section)
 540             expld.result.section = NULL;
 541           break;
 542
 543         case MAX_K:
 544           if (lhs.value > expld.result.value)
 545             expld.result.value = lhs.value;
 546           break;
 547
 548         case MIN_K:
 549           if (lhs.value < expld.result.value)
 550             expld.result.value = lhs.value;
 551           break;
 552
 553         case ALIGN_K:
 554           expld.result.value = align_n (lhs.value, expld.result.value);
 555           break;
 556
 557         case DATA_SEGMENT_ALIGN:
 558           expld.dataseg.relro = exp_dataseg_relro_start;
 559           if (expld.phase == lang_first_phase_enum
 560               || expld.section != bfd_abs_section_ptr)
 561             expld.result.valid_p = FALSE;
 562           else
 563             {
 564               bfd_vma maxpage = lhs.value;
 565               bfd_vma commonpage = expld.result.value;
 566
 567               expld.result.value = align_n (expld.dot, maxpage);
 568               if (expld.dataseg.phase == exp_dataseg_relro_adjust)
 569                 expld.result.value = expld.dataseg.base;
 570               else if (expld.dataseg.phase == exp_dataseg_adjust)
 571                 {
 572                   if (commonpage < maxpage)
 573                     expld.result.value += ((expld.dot + commonpage - 1)
 574                                            & (maxpage - commonpage));
 575                 }
 576               else
 577                 {
 578                   expld.result.value += expld.dot & (maxpage - 1);
 579                   if (expld.dataseg.phase == exp_dataseg_done)
 580                     {
 581                       /* OK.  */
 582                     }
 583                   else if (expld.dataseg.phase == exp_dataseg_none)
 584                     {
 585                       expld.dataseg.phase = exp_dataseg_align_seen;
 586                       expld.dataseg.base = expld.result.value;
 587                       expld.dataseg.pagesize = commonpage;
 588                       expld.dataseg.maxpagesize = maxpage;
 589                       expld.dataseg.relro_end = 0;
 590                     }
 591                   else
 592                     expld.result.valid_p = FALSE;
 593                 }
 594             }
 595           break;
 596
 597         case DATA_SEGMENT_RELRO_END:
 598           /* Operands swapped!  DATA_SEGMENT_RELRO_END(offset,exp)
 599              has offset in expld.result and exp in lhs.  */
 600           expld.dataseg.relro = exp_dataseg_relro_end;
 601           expld.dataseg.relro_offset = expld.result.value;
 602           if (expld.phase == lang_first_phase_enum
 603               || expld.section != bfd_abs_section_ptr)
 604             expld.result.valid_p = FALSE;
 605           else if (expld.dataseg.phase == exp_dataseg_align_seen
 606                    || expld.dataseg.phase == exp_dataseg_adjust
 607                    || expld.dataseg.phase == exp_dataseg_relro_adjust
 608                    || expld.dataseg.phase == exp_dataseg_done)
 609             {
 610               if (expld.dataseg.phase == exp_dataseg_align_seen
 611                   || expld.dataseg.phase == exp_dataseg_relro_adjust)
 612                 expld.dataseg.relro_end = lhs.value + expld.result.value;
 613
 614               if (expld.dataseg.phase == exp_dataseg_relro_adjust
 615                   && (expld.dataseg.relro_end
 616                       & (expld.dataseg.pagesize - 1)))
 617                 {
 618                   expld.dataseg.relro_end += expld.dataseg.pagesize - 1;
 619                   expld.dataseg.relro_end &= ~(expld.dataseg.pagesize - 1);
 620                   expld.result.value = (expld.dataseg.relro_end
 621                                         - expld.result.value);
 622                 }
 623               else
 624                 expld.result.value = lhs.value;
 625
 626               if (expld.dataseg.phase == exp_dataseg_align_seen)
 627                 expld.dataseg.phase = exp_dataseg_relro_seen;
 628             }
 629           else
 630             expld.result.valid_p = FALSE;
 631           break;
 632
 633         default:
 634           FAIL ();
 635         }
 636     }
 637 }
 638
 639 static void
 640 fold_trinary (etree_type *tree)
 641 {
 642   exp_fold_tree_1 (tree->trinary.cond);
 643   if (expld.result.valid_p)
 644     exp_fold_tree_1 (expld.result.value
 645                      ? tree->trinary.lhs
 646                      : tree->trinary.rhs);
 647 }
 648
 649 static void
 650 fold_name (etree_type *tree)
 651 {
 652   memset (&expld.result, 0, sizeof (expld.result));
 653
 654   switch (tree->type.node_code)
 655     {
 656     case SIZEOF_HEADERS:
 657       if (expld.phase != lang_first_phase_enum)
 658         {
 659           bfd_vma hdr_size = 0;
 660           /* Don't find the real header size if only marking sections;
 661              The bfd function may cache incorrect data.  */
 662           if (expld.phase != lang_mark_phase_enum)
 663             hdr_size = bfd_sizeof_headers (link_info.output_bfd, &link_info);
 664           new_number (hdr_size);
 665         }
 666       break;
 667
 668     case DEFINED:
 669       if (expld.phase != lang_first_phase_enum)
 670         {
 671           struct bfd_link_hash_entry *h;
 672           struct definedness_hash_entry *def;
 673
 674           h = bfd_wrapped_link_hash_lookup (link_info.output_bfd,
 675                                             &link_info,
 676                                             tree->name.name,
 677                                             FALSE, FALSE, TRUE);
 678           new_number (h != NULL
 679                       && (h->type == bfd_link_hash_defined
 680                           || h->type == bfd_link_hash_defweak
 681                           || h->type == bfd_link_hash_common)
 682                       && ((def = symbol_defined (tree->name.name)) == NULL
 683                           || def->by_object
 684                           || def->iteration == (lang_statement_iteration & 1)));
 685         }
 686       break;
 687
 688     case NAME:
 689       if (expld.assign_name != NULL
 690           && strcmp (expld.assign_name, tree->name.name) == 0)
 691         {
 692           /* Self-assignment is only allowed for absolute symbols
 693              defined in a linker script.  */
 694           struct bfd_link_hash_entry *h;
 695           struct definedness_hash_entry *def;
 696
 697           h = bfd_wrapped_link_hash_lookup (link_info.output_bfd,
 698                                             &link_info,
 699                                             tree->name.name,
 700                                             FALSE, FALSE, TRUE);
 701           if (!(h != NULL
 702                 && (h->type == bfd_link_hash_defined
 703                     || h->type == bfd_link_hash_defweak)
 704                 && h->u.def.section == bfd_abs_section_ptr
 705                 && (def = symbol_defined (tree->name.name)) != NULL
 706                 && def->iteration == (lang_statement_iteration & 1)))
 707             expld.assign_name = NULL;
 708         }
 709       if (expld.phase == lang_first_phase_enum)
 710         ;
 711       else if (tree->name.name[0] == '.' && tree->name.name[1] == 0)
 712         new_rel_from_abs (expld.dot);
 713       else
 714         {
 715           struct bfd_link_hash_entry *h;
 716
 717           h = bfd_wrapped_link_hash_lookup (link_info.output_bfd,
 718                                             &link_info,
 719                                             tree->name.name,
 720                                             TRUE, FALSE, TRUE);
 721           if (!h)
 722             einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
 723           else if (h->type == bfd_link_hash_defined
 724                    || h->type == bfd_link_hash_defweak)
 725             {
 726               asection *output_section;
 727
 728               output_section = h->u.def.section->output_section;
 729               if (output_section == NULL)
 730                 {
 731                   if (expld.phase == lang_mark_phase_enum)
 732                     new_rel (h->u.def.value, h->u.def.section);
 733                   else
 734                     einfo (_("%X%S: unresolvable symbol `%s'"
 735                              " referenced in expression\n"),
 736                            tree, tree->name.name);
 737                 }
 738               else if (output_section == bfd_abs_section_ptr
 739                        && (expld.section != bfd_abs_section_ptr
 740                            || config.sane_expr))
 741                 new_number (h->u.def.value + h->u.def.section->output_offset);
 742               else
 743                 new_rel (h->u.def.value + h->u.def.section->output_offset,
 744                          output_section);
 745             }
 746           else if (expld.phase == lang_final_phase_enum
 747                    || (expld.phase != lang_mark_phase_enum
 748                        && expld.assigning_to_dot))
 749             einfo (_("%F%S: undefined symbol `%s'"
 750                      " referenced in expression\n"),
 751                    tree, tree->name.name);
 752           else if (h->type == bfd_link_hash_new)
 753             {
 754               h->type = bfd_link_hash_undefined;
 755               h->u.undef.abfd = NULL;
 756               if (h->u.undef.next == NULL && h != link_info.hash->undefs_tail)
 757                 bfd_link_add_undef (link_info.hash, h);
 758             }
 759         }
 760       break;
 761
 762     case ADDR:
 763       if (expld.phase != lang_first_phase_enum)
 764         {
 765           lang_output_section_statement_type *os;
 766
 767           os = lang_output_section_find (tree->name.name);
 768           if (os == NULL)
 769             {
 770               if (expld.phase == lang_final_phase_enum)
 771                 einfo (_("%F%S: undefined section `%s'"
 772                          " referenced in expression\n"),
 773                        tree, tree->name.name);
 774             }
 775           else if (os->processed_vma)
 776             new_rel (0, os->bfd_section);
 777         }
 778       break;
 779
 780     case LOADADDR:
 781       if (expld.phase != lang_first_phase_enum)
 782         {
 783           lang_output_section_statement_type *os;
 784
 785           os = lang_output_section_find (tree->name.name);
 786           if (os == NULL)
 787             {
 788               if (expld.phase == lang_final_phase_enum)
 789                 einfo (_("%F%S: undefined section `%s'"
 790                          " referenced in expression\n"),
 791                        tree, tree->name.name);
 792             }
 793           else if (os->processed_lma)
 794             {
 795               if (os->load_base == NULL)
 796                 new_abs (os->bfd_section->lma);
 797               else
 798                 {
 799                   exp_fold_tree_1 (os->load_base);
 800                   if (expld.result.valid_p)
 801                     make_abs ();
 802                 }
 803             }
 804         }
 805       break;
 806
 807     case SIZEOF:
 808     case ALIGNOF:
 809       if (expld.phase != lang_first_phase_enum)
 810         {
 811           lang_output_section_statement_type *os;
 812
 813           os = lang_output_section_find (tree->name.name);
 814           if (os == NULL)
 815             {
 816               if (expld.phase == lang_final_phase_enum)
 817                 einfo (_("%F%S: undefined section `%s'"
 818                          " referenced in expression\n"),
 819                        tree, tree->name.name);
 820               new_number (0);
 821             }
 822           else if (os->bfd_section != NULL)
 823             {
 824               bfd_vma val;
 825
 826               if (tree->type.node_code == SIZEOF)
 827                 val = (os->bfd_section->size
 828                        / bfd_octets_per_byte (link_info.output_bfd));
 829               else
 830                 val = (bfd_vma)1 << os->bfd_section->alignment_power;
 831
 832               new_number (val);
 833             }
 834           else
 835             new_number (0);
 836         }
 837       break;
 838
 839     case LENGTH:
 840       {
 841       if (expld.phase != lang_first_phase_enum)
 842         {
 843           lang_memory_region_type *mem;
 844
 845           mem = lang_memory_region_lookup (tree->name.name, FALSE);
 846           if (mem != NULL)
 847             new_number (mem->length);
 848           else
 849             einfo (_("%F%S: undefined MEMORY region `%s'"
 850              " referenced in expression\n"),
 851            tree, tree->name.name);
 852         }
 853       }
 854       break;
 855
 856     case ORIGIN:
 857       if (expld.phase != lang_first_phase_enum)
 858         {
 859           lang_memory_region_type *mem;
 860
 861           mem = lang_memory_region_lookup (tree->name.name, FALSE);
 862           if (mem != NULL)
 863             new_rel_from_abs (mem->origin);
 864           else
 865             einfo (_("%F%S: undefined MEMORY region `%s'"
 866                      " referenced in expression\n"),
 867                    tree, tree->name.name);
 868         }
 869       break;
 870
 871     case CONSTANT:
 872       if (strcmp (tree->name.name, "MAXPAGESIZE") == 0)
 873         new_number (config.maxpagesize);
 874       else if (strcmp (tree->name.name, "COMMONPAGESIZE") == 0)
 875         new_number (config.commonpagesize);
 876       else
 877         einfo (_("%F%S: unknown constant `%s' referenced in expression\n"),
 878                tree, tree->name.name);
 879       break;
 880
 881     default:
 882       FAIL ();
 883       break;
 884     }
 885 }
 886
 887 /* Return true if TREE is '.'.  */
 888
 889 static bfd_boolean
 890 is_dot (const etree_type *tree)
 891 {
 892   return (tree->type.node_class == etree_name
 893           && tree->type.node_code == NAME
 894           && tree->name.name[0] == '.'
 895           && tree->name.name[1] == 0);
 896 }
 897
 898 /* Return true if TREE is a constant equal to VAL.  */
 899
 900 static bfd_boolean
 901 is_value (const etree_type *tree, bfd_vma val)
 902 {
 903   return (tree->type.node_class == etree_value
 904           && tree->value.value == val);
 905 }
 906
 907 /* Return true if TREE is an absolute symbol equal to VAL defined in
 908    a linker script.  */
 909
 910 static bfd_boolean
 911 is_sym_value (const etree_type *tree, bfd_vma val)
 912 {
 913   struct bfd_link_hash_entry *h;
 914   struct definedness_hash_entry *def;
 915
 916   return (tree->type.node_class == etree_name
 917           && tree->type.node_code == NAME
 918           && (def = symbol_defined (tree->name.name)) != NULL
 919           && def->by_script
 920           && def->iteration == (lang_statement_iteration & 1)
 921           && (h = bfd_wrapped_link_hash_lookup (link_info.output_bfd,
 922                                                 &link_info,
 923                                                 tree->name.name,
 924                                                 FALSE, FALSE, TRUE)) != NULL
 925           && h->type == bfd_link_hash_defined
 926           && h->u.def.section == bfd_abs_section_ptr
 927           && h->u.def.value == val);
 928 }
 929
 930 /* Return true if TREE is ". != 0".  */
 931
 932 static bfd_boolean
 933 is_dot_ne_0 (const etree_type *tree)
 934 {
 935   return (tree->type.node_class == etree_binary
 936           && tree->type.node_code == NE
 937           && is_dot (tree->binary.lhs)
 938           && is_value (tree->binary.rhs, 0));
 939 }
 940
 941 /* Return true if TREE is ". = . + 0" or ". = . + sym" where sym is an
 942    absolute constant with value 0 defined in a linker script.  */
 943
 944 static bfd_boolean
 945 is_dot_plus_0 (const etree_type *tree)
 946 {
 947   return (tree->type.node_class == etree_binary
 948           && tree->type.node_code == '+'
 949           && is_dot (tree->binary.lhs)
 950           && (is_value (tree->binary.rhs, 0)
 951               || is_sym_value (tree->binary.rhs, 0)));
 952 }
 953
 954 /* Return true if TREE is "ALIGN (. != 0 ? some_expression : 1)",
 955    or equivalent binary ALIGN expressions.  */
 956
 957 static bfd_boolean
 958 is_align_conditional (const etree_type *tree)
 959 {
 960   if (tree->type.node_code != ALIGN_K)
 961     return 0;
 962   else if (tree->type.node_class == etree_unary)
 963     tree = tree->unary.child;
 964   else if (tree->type.node_class == etree_binary
 965            && (is_dot (tree->binary.lhs)
 966                || (tree->binary.lhs->type.node_class == etree_unary
 967                    && tree->binary.lhs->type.node_code == ABSOLUTE
 968                    && is_dot (tree->binary.lhs->unary.child))))
 969     tree = tree->binary.rhs;
 970   else
 971     return 0;
 972
 973   return (tree->type.node_class == etree_trinary
 974           && is_dot_ne_0 (tree->trinary.cond)
 975           && is_value (tree->trinary.rhs, 1));
 976 }
 977
 978 static void
 979 exp_fold_tree_1 (etree_type *tree)
 980 {
 981   if (tree == NULL)
 982     {
 983       memset (&expld.result, 0, sizeof (expld.result));
 984       return;
 985     }
 986
 987   switch (tree->type.node_class)
 988     {
 989     case etree_value:
 990       if (expld.section == bfd_abs_section_ptr
 991           && !config.sane_expr)
 992         new_abs (tree->value.value);
 993       else
 994         new_number (tree->value.value);
 995       expld.result.str = tree->value.str;
 996       break;
 997
 998     case etree_rel:
 999       if (expld.phase != lang_first_phase_enum)
1000         {
1001           asection *output_section = tree->rel.section->output_section;
1002           new_rel (tree->rel.value + tree->rel.section->output_offset,
1003                    output_section);
1004         }
1005       else
1006         memset (&expld.result, 0, sizeof (expld.result));
1007       break;
1008
1009     case etree_assert:
1010       exp_fold_tree_1 (tree->assert_s.child);
1011       if (expld.phase == lang_final_phase_enum && !expld.result.value)
1012         einfo ("%X%P: %s\n", tree->assert_s.message);
1013       break;
1014
1015     case etree_unary:
1016       fold_unary (tree);
1017       break;
1018
1019     case etree_binary:
1020       fold_binary (tree);
1021       break;
1022
1023     case etree_trinary:
1024       fold_trinary (tree);
1025       break;
1026
1027     case etree_assign:
1028     case etree_provide:
1029     case etree_provided:
1030       if (tree->assign.dst[0] == '.' && tree->assign.dst[1] == 0)
1031         {
1032           if (tree->type.node_class != etree_assign)
1033             einfo (_("%F%S can not PROVIDE assignment to"
1034                      " location counter\n"), tree);
1035           if (expld.phase != lang_first_phase_enum)
1036             {
1037               /* Notify the folder that this is an assignment to dot.  */
1038               expld.assigning_to_dot = TRUE;
1039               exp_fold_tree_1 (tree->assign.src);
1040               expld.assigning_to_dot = FALSE;
1041
1042               if (!expld.result.valid_p)
1043                 {
1044                   if (expld.phase != lang_mark_phase_enum)
1045                     einfo (_("%F%S invalid assignment to"
1046                              " location counter\n"), tree);
1047                   else if (expld.section != bfd_abs_section_ptr)
1048                     expld.section->flags |= SEC_KEEP;
1049                 }
1050               else if (expld.dotp == NULL)
1051                 einfo (_("%F%S assignment to location counter"
1052                          " invalid outside of SECTIONS\n"), tree);
1053
1054               /* After allocation, assignment to dot should not be
1055                  done inside an output section since allocation adds a
1056                  padding statement that effectively duplicates the
1057                  assignment.  */
1058               else if (expld.phase <= lang_allocating_phase_enum
1059                        || expld.section == bfd_abs_section_ptr)
1060                 {
1061                   bfd_vma nextdot;
1062
1063                   nextdot = expld.result.value;
1064                   if (expld.result.section != NULL)
1065                     nextdot += expld.result.section->vma;
1066                   else
1067                     nextdot += expld.section->vma;
1068
1069                   /* If we are assigning to dot inside an output
1070                      section arrange to keep the section, except for
1071                      certain expressions that evaluate to zero.  We
1072                      can't ignore all expressions that evaluate to
1073                      zero because an otherwise empty section might
1074                      have padding added by an alignment expression
1075                      that changes with relaxation.  Such a section
1076                      might have zero size before relaxation and so be
1077                      stripped incorrectly.  */
1078                   if (expld.phase == lang_mark_phase_enum
1079                       && expld.section != bfd_abs_section_ptr
1080                       && !(nextdot == expld.section->vma
1081                            && (is_value (tree->assign.src, 0)
1082                                || is_sym_value (tree->assign.src, 0)
1083                                || is_dot_plus_0 (tree->assign.src)
1084                                || is_align_conditional (tree->assign.src))))
1085                     expld.section->flags |= SEC_KEEP;
1086
1087                   if (nextdot < expld.dot
1088                       && expld.section != bfd_abs_section_ptr)
1089                     einfo (_("%F%S cannot move location counter backwards"
1090                              " (from %V to %V)\n"),
1091                            tree, expld.dot, nextdot);
1092                   else
1093                     {
1094                       expld.dot = nextdot;
1095                       *expld.dotp = nextdot;
1096                     }
1097                 }
1098             }
1099           else
1100             memset (&expld.result, 0, sizeof (expld.result));
1101         }
1102       else
1103         {
1104           struct bfd_link_hash_entry *h = NULL;
1105
1106           if (tree->type.node_class == etree_provide)
1107             {
1108               h = bfd_link_hash_lookup (link_info.hash, tree->assign.dst,
1109                                         FALSE, FALSE, TRUE);
1110               if (h == NULL
1111                   || !(h->type == bfd_link_hash_new
1112                        || h->type == bfd_link_hash_undefined
1113                        || h->linker_def))
1114                 {
1115                   /* Do nothing.  The symbol was never referenced, or
1116                      was defined in some object file.  Undefined weak
1117                      symbols stay undefined.  */
1118                   break;
1119                 }
1120             }
1121
1122           expld.assign_name = tree->assign.dst;
1123           exp_fold_tree_1 (tree->assign.src);
1124           /* expld.assign_name remaining equal to tree->assign.dst
1125              below indicates the evaluation of tree->assign.src did
1126              not use the value of tree->assign.dst.  We don't allow
1127              self assignment until the final phase for two reasons:
1128              1) Expressions are evaluated multiple times.  With
1129              relaxation, the number of times may vary.
1130              2) Section relative symbol values cannot be correctly
1131              converted to absolute values, as is required by many
1132              expressions, until final section sizing is complete.  */
1133           if ((expld.result.valid_p
1134                && (expld.phase == lang_final_phase_enum
1135                    || expld.assign_name != NULL))
1136               || (expld.phase <= lang_mark_phase_enum
1137                   && tree->type.node_class == etree_assign
1138                   && tree->assign.defsym))
1139             {
1140               if (h == NULL)
1141                 {
1142                   h = bfd_link_hash_lookup (link_info.hash, tree->assign.dst,
1143                                             TRUE, FALSE, TRUE);
1144                   if (h == NULL)
1145                     einfo (_("%P%F:%s: hash creation failed\n"),
1146                            tree->assign.dst);
1147                 }
1148
1149               if (expld.result.section == NULL)
1150                 expld.result.section = expld.section;
1151               if (!update_definedness (tree->assign.dst, h) && 0)
1152                 {
1153                   /* Symbol was already defined.  For now this error
1154                      is disabled because it causes failures in the ld
1155                      testsuite: ld-elf/var1, ld-scripts/defined5, and
1156                      ld-scripts/pr14962.  Some of these no doubt
1157                      reflect scripts used in the wild.  */
1158                   (*link_info.callbacks->multiple_definition)
1159                     (&link_info, h, link_info.output_bfd,
1160                      expld.result.section, expld.result.value);
1161                 }
1162               h->type = bfd_link_hash_defined;
1163               h->u.def.value = expld.result.value;
1164               h->u.def.section = expld.result.section;
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.dot = *dotp;
1210   expld.dotp = dotp;
1211   expld.section = current_section;
1212   exp_fold_tree_1 (tree);
1213 }
1214
1215 void
1216 exp_fold_tree_no_dot (etree_type *tree)
1217 {
1218   expld.dot = 0;
1219   expld.dotp = NULL;
1220   expld.section = bfd_abs_section_ptr;
1221   exp_fold_tree_1 (tree);
1222 }
1223
1224 etree_type *
1225 exp_binop (int code, etree_type *lhs, etree_type *rhs)
1226 {
1227   etree_type value, *new_e;
1228
1229   value.type.node_code = code;
1230   value.type.filename = lhs->type.filename;
1231   value.type.lineno = lhs->type.lineno;
1232   value.binary.lhs = lhs;
1233   value.binary.rhs = rhs;
1234   value.type.node_class = etree_binary;
1235   exp_fold_tree_no_dot (&value);
1236   if (expld.result.valid_p)
1237     return exp_intop (expld.result.value);
1238
1239   new_e = (etree_type *) stat_alloc (sizeof (new_e->binary));
1240   memcpy (new_e, &value, sizeof (new_e->binary));
1241   return new_e;
1242 }
1243
1244 etree_type *
1245 exp_trinop (int code, etree_type *cond, etree_type *lhs, etree_type *rhs)
1246 {
1247   etree_type value, *new_e;
1248
1249   value.type.node_code = code;
1250   value.type.filename = cond->type.filename;
1251   value.type.lineno = cond->type.lineno;
1252   value.trinary.lhs = lhs;
1253   value.trinary.cond = cond;
1254   value.trinary.rhs = rhs;
1255   value.type.node_class = etree_trinary;
1256   exp_fold_tree_no_dot (&value);
1257   if (expld.result.valid_p)
1258     return exp_intop (expld.result.value);
1259
1260   new_e = (etree_type *) stat_alloc (sizeof (new_e->trinary));
1261   memcpy (new_e, &value, sizeof (new_e->trinary));
1262   return new_e;
1263 }
1264
1265 etree_type *
1266 exp_unop (int code, etree_type *child)
1267 {
1268   etree_type value, *new_e;
1269
1270   value.unary.type.node_code = code;
1271   value.unary.type.filename = child->type.filename;
1272   value.unary.type.lineno = child->type.lineno;
1273   value.unary.child = child;
1274   value.unary.type.node_class = etree_unary;
1275   exp_fold_tree_no_dot (&value);
1276   if (expld.result.valid_p)
1277     return exp_intop (expld.result.value);
1278
1279   new_e = (etree_type *) stat_alloc (sizeof (new_e->unary));
1280   memcpy (new_e, &value, sizeof (new_e->unary));
1281   return new_e;
1282 }
1283
1284 etree_type *
1285 exp_nameop (int code, const char *name)
1286 {
1287   etree_type value, *new_e;
1288
1289   value.name.type.node_code = code;
1290   value.name.type.filename = ldlex_filename ();
1291   value.name.type.lineno = lineno;
1292   value.name.name = name;
1293   value.name.type.node_class = etree_name;
1294
1295   exp_fold_tree_no_dot (&value);
1296   if (expld.result.valid_p)
1297     return exp_intop (expld.result.value);
1298
1299   new_e = (etree_type *) stat_alloc (sizeof (new_e->name));
1300   memcpy (new_e, &value, sizeof (new_e->name));
1301   return new_e;
1302
1303 }
1304
1305 static etree_type *
1306 exp_assop (const char *dst,
1307            etree_type *src,
1308            enum node_tree_enum class,
1309            bfd_boolean defsym,
1310            bfd_boolean hidden)
1311 {
1312   etree_type *n;
1313
1314   n = (etree_type *) stat_alloc (sizeof (n->assign));
1315   n->assign.type.node_code = '=';
1316   n->assign.type.filename = src->type.filename;
1317   n->assign.type.lineno = src->type.lineno;
1318   n->assign.type.node_class = class;
1319   n->assign.src = src;
1320   n->assign.dst = dst;
1321   n->assign.defsym = defsym;
1322   n->assign.hidden = hidden;
1323   return n;
1324 }
1325
1326 /* Handle linker script assignments and HIDDEN.  */
1327
1328 etree_type *
1329 exp_assign (const char *dst, etree_type *src, bfd_boolean hidden)
1330 {
1331   return exp_assop (dst, src, etree_assign, FALSE, hidden);
1332 }
1333
1334 /* Handle --defsym command-line option.  */
1335
1336 etree_type *
1337 exp_defsym (const char *dst, etree_type *src)
1338 {
1339   return exp_assop (dst, src, etree_assign, TRUE, FALSE);
1340 }
1341
1342 /* Handle PROVIDE.  */
1343
1344 etree_type *
1345 exp_provide (const char *dst, etree_type *src, bfd_boolean hidden)
1346 {
1347   return exp_assop (dst, src, etree_provide, FALSE, hidden);
1348 }
1349
1350 /* Handle ASSERT.  */
1351
1352 etree_type *
1353 exp_assert (etree_type *exp, const char *message)
1354 {
1355   etree_type *n;
1356
1357   n = (etree_type *) stat_alloc (sizeof (n->assert_s));
1358   n->assert_s.type.node_code = '!';
1359   n->assert_s.type.filename = exp->type.filename;
1360   n->assert_s.type.lineno = exp->type.lineno;
1361   n->assert_s.type.node_class = etree_assert;
1362   n->assert_s.child = exp;
1363   n->assert_s.message = message;
1364   return n;
1365 }
1366
1367 void
1368 exp_print_tree (etree_type *tree)
1369 {
1370   bfd_boolean function_like;
1371
1372   if (config.map_file == NULL)
1373     config.map_file = stderr;
1374
1375   if (tree == NULL)
1376     {
1377       minfo ("NULL TREE\n");
1378       return;
1379     }
1380
1381   switch (tree->type.node_class)
1382     {
1383     case etree_value:
1384       minfo ("0x%v", tree->value.value);
1385       return;
1386     case etree_rel:
1387       if (tree->rel.section->owner != NULL)
1388         minfo ("%B:", tree->rel.section->owner);
1389       minfo ("%s+0x%v", tree->rel.section->name, tree->rel.value);
1390       return;
1391     case etree_assign:
1392       fputs (tree->assign.dst, config.map_file);
1393       exp_print_token (tree->type.node_code, TRUE);
1394       exp_print_tree (tree->assign.src);
1395       break;
1396     case etree_provide:
1397     case etree_provided:
1398       fprintf (config.map_file, "PROVIDE (%s, ", tree->assign.dst);
1399       exp_print_tree (tree->assign.src);
1400       fputc (')', config.map_file);
1401       break;
1402     case etree_binary:
1403       function_like = FALSE;
1404       switch (tree->type.node_code)
1405         {
1406         case MAX_K:
1407         case MIN_K:
1408         case ALIGN_K:
1409         case DATA_SEGMENT_ALIGN:
1410         case DATA_SEGMENT_RELRO_END:
1411           function_like = TRUE;
1412           break;
1413         case SEGMENT_START:
1414           /* Special handling because arguments are in reverse order and
1415              the segment name is quoted.  */
1416           exp_print_token (tree->type.node_code, FALSE);
1417           fputs (" (\"", config.map_file);
1418           exp_print_tree (tree->binary.rhs);
1419           fputs ("\", ", config.map_file);
1420           exp_print_tree (tree->binary.lhs);
1421           fputc (')', config.map_file);
1422           return;
1423         }
1424       if (function_like)
1425         {
1426           exp_print_token (tree->type.node_code, FALSE);
1427           fputc (' ', config.map_file);
1428         }
1429       fputc ('(', config.map_file);
1430       exp_print_tree (tree->binary.lhs);
1431       if (function_like)
1432         fprintf (config.map_file, ", ");
1433       else
1434         exp_print_token (tree->type.node_code, TRUE);
1435       exp_print_tree (tree->binary.rhs);
1436       fputc (')', config.map_file);
1437       break;
1438     case etree_trinary:
1439       exp_print_tree (tree->trinary.cond);
1440       fputc ('?', config.map_file);
1441       exp_print_tree (tree->trinary.lhs);
1442       fputc (':', config.map_file);
1443       exp_print_tree (tree->trinary.rhs);
1444       break;
1445     case etree_unary:
1446       exp_print_token (tree->unary.type.node_code, FALSE);
1447       if (tree->unary.child)
1448         {
1449           fprintf (config.map_file, " (");
1450           exp_print_tree (tree->unary.child);
1451           fputc (')', config.map_file);
1452         }
1453       break;
1454
1455     case etree_assert:
1456       fprintf (config.map_file, "ASSERT (");
1457       exp_print_tree (tree->assert_s.child);
1458       fprintf (config.map_file, ", %s)", tree->assert_s.message);
1459       break;
1460
1461     case etree_name:
1462       if (tree->type.node_code == NAME)
1463         fputs (tree->name.name, config.map_file);
1464       else
1465         {
1466           exp_print_token (tree->type.node_code, FALSE);
1467           if (tree->name.name)
1468             fprintf (config.map_file, " (%s)", tree->name.name);
1469         }
1470       break;
1471     default:
1472       FAIL ();
1473       break;
1474     }
1475 }
1476
1477 bfd_vma
1478 exp_get_vma (etree_type *tree, bfd_vma def, char *name)
1479 {
1480   if (tree != NULL)
1481     {
1482       exp_fold_tree_no_dot (tree);
1483       if (expld.result.valid_p)
1484         return expld.result.value;
1485       else if (name != NULL && expld.phase != lang_mark_phase_enum)
1486         einfo (_("%F%S: nonconstant expression for %s\n"),
1487                tree, name);
1488     }
1489   return def;
1490 }
1491
1492 int
1493 exp_get_value_int (etree_type *tree, int def, char *name)
1494 {
1495   return exp_get_vma (tree, def, name);
1496 }
1497
1498 fill_type *
1499 exp_get_fill (etree_type *tree, fill_type *def, char *name)
1500 {
1501   fill_type *fill;
1502   size_t len;
1503   unsigned int val;
1504
1505   if (tree == NULL)
1506     return def;
1507
1508   exp_fold_tree_no_dot (tree);
1509   if (!expld.result.valid_p)
1510     {
1511       if (name != NULL && expld.phase != lang_mark_phase_enum)
1512         einfo (_("%F%S: nonconstant expression for %s\n"),
1513                tree, name);
1514       return def;
1515     }
1516
1517   if (expld.result.str != NULL && (len = strlen (expld.result.str)) != 0)
1518     {
1519       unsigned char *dst;
1520       unsigned char *s;
1521       fill = (fill_type *) xmalloc ((len + 1) / 2 + sizeof (*fill) - 1);
1522       fill->size = (len + 1) / 2;
1523       dst = fill->data;
1524       s = (unsigned char *) expld.result.str;
1525       val = 0;
1526       do
1527         {
1528           unsigned int digit;
1529
1530           digit = *s++ - '0';
1531           if (digit > 9)
1532             digit = (digit - 'A' + '0' + 10) & 0xf;
1533           val <<= 4;
1534           val += digit;
1535           --len;
1536           if ((len & 1) == 0)
1537             {
1538               *dst++ = val;
1539               val = 0;
1540             }
1541         }
1542       while (len != 0);
1543     }
1544   else
1545     {
1546       fill = (fill_type *) xmalloc (4 + sizeof (*fill) - 1);
1547       val = expld.result.value;
1548       fill->data[0] = (val >> 24) & 0xff;
1549       fill->data[1] = (val >> 16) & 0xff;
1550       fill->data[2] = (val >>  8) & 0xff;
1551       fill->data[3] = (val >>  0) & 0xff;
1552       fill->size = 4;
1553     }
1554   return fill;
1555 }
1556
1557 bfd_vma
1558 exp_get_abs_int (etree_type *tree, int def, char *name)
1559 {
1560   if (tree != NULL)
1561     {
1562       exp_fold_tree_no_dot (tree);
1563
1564       if (expld.result.valid_p)
1565         {
1566           if (expld.result.section != NULL)
1567             expld.result.value += expld.result.section->vma;
1568           return expld.result.value;
1569         }
1570       else if (name != NULL && expld.phase != lang_mark_phase_enum)
1571         {
1572           einfo (_("%F%S: nonconstant expression for %s\n"),
1573                  tree, name);
1574         }
1575     }
1576   return def;
1577 }
1578
1579 static bfd_vma
1580 align_n (bfd_vma value, bfd_vma align)
1581 {
1582   if (align <= 1)
1583     return value;
1584
1585   value = (value + align - 1) / align;
1586   return value * align;
1587 }
1588
1589 void
1590 ldexp_init (void)
1591 {
1592   /* The value "13" is ad-hoc, somewhat related to the expected number of
1593      assignments in a linker script.  */
1594   if (!bfd_hash_table_init_n (&definedness_table,
1595                               definedness_newfunc,
1596                               sizeof (struct definedness_hash_entry),
1597                               13))
1598     einfo (_("%P%F: can not create hash table: %E\n"));
1599 }
1600
1601 void
1602 ldexp_finish (void)
1603 {
1604   bfd_hash_table_free (&definedness_table);
1605 }