ld/ldexp.c

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