ld/ldexp.c

   1 /* This module handles expression trees.
   2    Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
   3    2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
   4    Free Software Foundation, Inc.
   5    Written by Steve Chamberlain of Cygnus Support <sac@cygnus.com>.
   6
   7    This file is part of the GNU Binutils.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program; if not, write to the Free Software
  21    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  22    MA 02110-1301, USA.  */
  23
  24
  25 /* This module is in charge of working out the contents of expressions.
  26
  27    It has to keep track of the relative/absness of a symbol etc. This
  28    is done by keeping all values in a struct (an etree_value_type)
  29    which contains a value, a section to which it is relative and a
  30    valid bit.  */
  31
  32 #include "sysdep.h"
  33 #include "bfd.h"
  34 #include "bfdlink.h"
  35
  36 #include "ld.h"
  37 #include "ldmain.h"
  38 #include "ldmisc.h"
  39 #include "ldexp.h"
  40 #include "ldlex.h"
  41 #include <ldgram.h>
  42 #include "ldlang.h"
  43 #include "libiberty.h"
  44 #include "safe-ctype.h"
  45
  46 static void exp_fold_tree_1 (etree_type *);
  47 static bfd_vma align_n (bfd_vma, bfd_vma);
  48
  49 segment_type *segments;
  50
  51 struct ldexp_control expld;
  52
  53 /* Print the string representation of the given token.  Surround it
  54    with spaces if INFIX_P is TRUE.  */
  55
  56 static void
  57 exp_print_token (token_code_type code, int infix_p)
  58 {
  59   static const struct
  60   {
  61     token_code_type code;
  62     char * name;
  63   }
  64   table[] =
  65   {
  66     { INT, "int" },
  67     { NAME, "NAME" },
  68     { PLUSEQ, "+=" },
  69     { MINUSEQ, "-=" },
  70     { MULTEQ, "*=" },
  71     { DIVEQ, "/=" },
  72     { LSHIFTEQ, "<<=" },
  73     { RSHIFTEQ, ">>=" },
  74     { ANDEQ, "&=" },
  75     { OREQ, "|=" },
  76     { OROR, "||" },
  77     { ANDAND, "&&" },
  78     { EQ, "==" },
  79     { NE, "!=" },
  80     { LE, "<=" },
  81     { GE, ">=" },
  82     { LSHIFT, "<<" },
  83     { RSHIFT, ">>" },
  84     { ALIGN_K, "ALIGN" },
  85     { BLOCK, "BLOCK" },
  86     { QUAD, "QUAD" },
  87     { SQUAD, "SQUAD" },
  88     { LONG, "LONG" },
  89     { SHORT, "SHORT" },
  90     { BYTE, "BYTE" },
  91     { SECTIONS, "SECTIONS" },
  92     { SIZEOF_HEADERS, "SIZEOF_HEADERS" },
  93     { MEMORY, "MEMORY" },
  94     { DEFINED, "DEFINED" },
  95     { TARGET_K, "TARGET" },
  96     { SEARCH_DIR, "SEARCH_DIR" },
  97     { MAP, "MAP" },
  98     { ENTRY, "ENTRY" },
  99     { NEXT, "NEXT" },
 100     { ALIGNOF, "ALIGNOF" },
 101     { SIZEOF, "SIZEOF" },
 102     { ADDR, "ADDR" },
 103     { LOADADDR, "LOADADDR" },
 104     { CONSTANT, "CONSTANT" },
 105     { ABSOLUTE, "ABSOLUTE" },
 106     { MAX_K, "MAX" },
 107     { MIN_K, "MIN" },
 108     { ASSERT_K, "ASSERT" },
 109     { REL, "relocatable" },
 110     { DATA_SEGMENT_ALIGN, "DATA_SEGMENT_ALIGN" },
 111     { DATA_SEGMENT_RELRO_END, "DATA_SEGMENT_RELRO_END" },
 112     { DATA_SEGMENT_END, "DATA_SEGMENT_END" },
 113     { ORIGIN, "ORIGIN" },
 114     { LENGTH, "LENGTH" },
 115     { SEGMENT_START, "SEGMENT_START" }
 116   };
 117   unsigned int idx;
 118
 119   for (idx = 0; idx < ARRAY_SIZE (table); idx++)
 120     if (table[idx].code == code)
 121       break;
 122
 123   if (infix_p)
 124     fputc (' ', config.map_file);
 125
 126   if (idx < ARRAY_SIZE (table))
 127     fputs (table[idx].name, config.map_file);
 128   else if (code < 127)
 129     fputc (code, config.map_file);
 130   else
 131     fprintf (config.map_file, "<code %d>", code);
 132
 133   if (infix_p)
 134     fputc (' ', config.map_file);
 135 }
 136
 137 static void
 138 make_abs (void)
 139 {
 140   if (expld.result.section != NULL)
 141     expld.result.value += expld.result.section->vma;
 142   expld.result.section = bfd_abs_section_ptr;
 143 }
 144
 145 static void
 146 new_abs (bfd_vma value)
 147 {
 148   expld.result.valid_p = TRUE;
 149   expld.result.section = bfd_abs_section_ptr;
 150   expld.result.value = value;
 151   expld.result.str = NULL;
 152 }
 153
 154 etree_type *
 155 exp_intop (bfd_vma value)
 156 {
 157   etree_type *new_e = (etree_type *) stat_alloc (sizeof (new_e->value));
 158   new_e->type.node_code = INT;
 159   new_e->type.lineno = lineno;
 160   new_e->value.value = value;
 161   new_e->value.str = NULL;
 162   new_e->type.node_class = etree_value;
 163   return new_e;
 164 }
 165
 166 etree_type *
 167 exp_bigintop (bfd_vma value, char *str)
 168 {
 169   etree_type *new_e = (etree_type *) stat_alloc (sizeof (new_e->value));
 170   new_e->type.node_code = INT;
 171   new_e->type.lineno = lineno;
 172   new_e->value.value = value;
 173   new_e->value.str = str;
 174   new_e->type.node_class = etree_value;
 175   return new_e;
 176 }
 177
 178 /* Build an expression representing an unnamed relocatable value.  */
 179
 180 etree_type *
 181 exp_relop (asection *section, bfd_vma value)
 182 {
 183   etree_type *new_e = (etree_type *) stat_alloc (sizeof (new_e->rel));
 184   new_e->type.node_code = REL;
 185   new_e->type.lineno = lineno;
 186   new_e->type.node_class = etree_rel;
 187   new_e->rel.section = section;
 188   new_e->rel.value = value;
 189   return new_e;
 190 }
 191
 192 static void
 193 new_number (bfd_vma value)
 194 {
 195   expld.result.valid_p = TRUE;
 196   expld.result.value = value;
 197   expld.result.str = NULL;
 198   expld.result.section = NULL;
 199 }
 200
 201 static void
 202 new_rel (bfd_vma value, asection *section)
 203 {
 204   expld.result.valid_p = TRUE;
 205   expld.result.value = value;
 206   expld.result.str = NULL;
 207   expld.result.section = section;
 208 }
 209
 210 static void
 211 new_rel_from_abs (bfd_vma value)
 212 {
 213   expld.result.valid_p = TRUE;
 214   expld.result.value = value - expld.section->vma;
 215   expld.result.str = NULL;
 216   expld.result.section = expld.section;
 217 }
 218
 219 static void
 220 fold_unary (etree_type *tree)
 221 {
 222   exp_fold_tree_1 (tree->unary.child);
 223   if (expld.result.valid_p)
 224     {
 225       switch (tree->type.node_code)
 226         {
 227         case ALIGN_K:
 228           if (expld.phase != lang_first_phase_enum)
 229             new_rel_from_abs (align_n (expld.dot, expld.result.value));
 230           else
 231             expld.result.valid_p = FALSE;
 232           break;
 233
 234         case ABSOLUTE:
 235           make_abs ();
 236           break;
 237
 238         case '~':
 239           expld.result.value = ~expld.result.value;
 240           break;
 241
 242         case '!':
 243           expld.result.value = !expld.result.value;
 244           break;
 245
 246         case '-':
 247           expld.result.value = -expld.result.value;
 248           break;
 249
 250         case NEXT:
 251           /* Return next place aligned to value.  */
 252           if (expld.phase != lang_first_phase_enum)
 253             {
 254               make_abs ();
 255               expld.result.value = align_n (expld.dot, expld.result.value);
 256             }
 257           else
 258             expld.result.valid_p = FALSE;
 259           break;
 260
 261         case DATA_SEGMENT_END:
 262           if (expld.phase == lang_first_phase_enum
 263               || expld.section != bfd_abs_section_ptr)
 264             {
 265               expld.result.valid_p = FALSE;
 266             }
 267           else if (expld.dataseg.phase == exp_dataseg_align_seen
 268                    || expld.dataseg.phase == exp_dataseg_relro_seen)
 269             {
 270               expld.dataseg.phase = exp_dataseg_end_seen;
 271               expld.dataseg.end = expld.result.value;
 272             }
 273           else if (expld.dataseg.phase == exp_dataseg_done
 274                    || expld.dataseg.phase == exp_dataseg_adjust
 275                    || expld.dataseg.phase == exp_dataseg_relro_adjust)
 276             {
 277               /* OK.  */
 278             }
 279           else
 280             expld.result.valid_p = FALSE;
 281           break;
 282
 283         default:
 284           FAIL ();
 285           break;
 286         }
 287     }
 288 }
 289
 290 static void
 291 fold_binary (etree_type *tree)
 292 {
 293   etree_value_type lhs;
 294   exp_fold_tree_1 (tree->binary.lhs);
 295
 296   /* The SEGMENT_START operator is special because its first
 297      operand is a string, not the name of a symbol.  Note that the
 298      operands have been swapped, so binary.lhs is second (default)
 299      operand, binary.rhs is first operand.  */
 300   if (expld.result.valid_p && tree->type.node_code == SEGMENT_START)
 301     {
 302       const char *segment_name;
 303       segment_type *seg;
 304
 305       /* Check to see if the user has overridden the default
 306          value.  */
 307       segment_name = tree->binary.rhs->name.name;
 308       for (seg = segments; seg; seg = seg->next)
 309         if (strcmp (seg->name, segment_name) == 0)
 310           {
 311             if (!seg->used
 312                 && config.magic_demand_paged
 313                 && (seg->value % config.maxpagesize) != 0)
 314               einfo (_("%P: warning: address of `%s' isn't multiple of maximum page size\n"),
 315                      segment_name);
 316             seg->used = TRUE;
 317             new_rel_from_abs (seg->value);
 318             break;
 319           }
 320       return;
 321     }
 322
 323   lhs = expld.result;
 324   exp_fold_tree_1 (tree->binary.rhs);
 325   expld.result.valid_p &= lhs.valid_p;
 326
 327   if (expld.result.valid_p)
 328     {
 329       if (lhs.section != expld.result.section)
 330         {
 331           /* If the values are from different sections, and neither is
 332              just a number, make both the source arguments absolute.  */
 333           if (expld.result.section != NULL
 334               && lhs.section != NULL)
 335             {
 336               make_abs ();
 337               lhs.value += lhs.section->vma;
 338             }
 339
 340           /* If the rhs is just a number, keep the lhs section.  */
 341           else if (expld.result.section == NULL)
 342             expld.result.section = lhs.section;
 343         }
 344
 345       switch (tree->type.node_code)
 346         {
 347         case '%':
 348           if (expld.result.value != 0)
 349             expld.result.value = ((bfd_signed_vma) lhs.value
 350                                   % (bfd_signed_vma) expld.result.value);
 351           else if (expld.phase != lang_mark_phase_enum)
 352             einfo (_("%F%S %% by zero\n"));
 353           break;
 354
 355         case '/':
 356           if (expld.result.value != 0)
 357             expld.result.value = ((bfd_signed_vma) lhs.value
 358                                   / (bfd_signed_vma) expld.result.value);
 359           else if (expld.phase != lang_mark_phase_enum)
 360             einfo (_("%F%S / by zero\n"));
 361           break;
 362
 363 #define BOP(x, y) \
 364         case x:                                                 \
 365           expld.result.value = lhs.value y expld.result.value;  \
 366           break;
 367
 368 #define BOPN(x, y) \
 369         case x:                                                 \
 370           expld.result.value = lhs.value y expld.result.value;  \
 371           expld.result.section = NULL;                          \
 372           break;
 373
 374           BOP ('+', +);
 375           BOP ('*', *);
 376           BOP ('-', -);
 377           BOP (LSHIFT, <<);
 378           BOP (RSHIFT, >>);
 379           BOP ('&', &);
 380           BOP ('^', ^);
 381           BOP ('|', |);
 382           BOPN (EQ, ==);
 383           BOPN (NE, !=);
 384           BOPN ('<', <);
 385           BOPN ('>', >);
 386           BOPN (LE, <=);
 387           BOPN (GE, >=);
 388           BOPN (ANDAND, &&);
 389           BOPN (OROR, ||);
 390
 391         case MAX_K:
 392           if (lhs.value > expld.result.value)
 393             expld.result.value = lhs.value;
 394           break;
 395
 396         case MIN_K:
 397           if (lhs.value < expld.result.value)
 398             expld.result.value = lhs.value;
 399           break;
 400
 401         case ALIGN_K:
 402           expld.result.value = align_n (lhs.value, expld.result.value);
 403           break;
 404
 405         case DATA_SEGMENT_ALIGN:
 406           expld.dataseg.relro = exp_dataseg_relro_start;
 407           if (expld.phase == lang_first_phase_enum
 408               || expld.section != bfd_abs_section_ptr)
 409             expld.result.valid_p = FALSE;
 410           else
 411             {
 412               bfd_vma maxpage = lhs.value;
 413               bfd_vma commonpage = expld.result.value;
 414
 415               expld.result.value = align_n (expld.dot, maxpage);
 416               if (expld.dataseg.phase == exp_dataseg_relro_adjust)
 417                 expld.result.value = expld.dataseg.base;
 418               else if (expld.dataseg.phase == exp_dataseg_adjust)
 419                 {
 420                   if (commonpage < maxpage)
 421                     expld.result.value += ((expld.dot + commonpage - 1)
 422                                            & (maxpage - commonpage));
 423                 }
 424               else
 425                 {
 426                   expld.result.value += expld.dot & (maxpage - 1);
 427                   if (expld.dataseg.phase == exp_dataseg_done)
 428                     {
 429                       /* OK.  */
 430                     }
 431                   else if (expld.dataseg.phase == exp_dataseg_none)
 432                     {
 433                       expld.dataseg.phase = exp_dataseg_align_seen;
 434                       expld.dataseg.min_base = expld.dot;
 435                       expld.dataseg.base = expld.result.value;
 436                       expld.dataseg.pagesize = commonpage;
 437                       expld.dataseg.maxpagesize = maxpage;
 438                       expld.dataseg.relro_end = 0;
 439                     }
 440                   else
 441                     expld.result.valid_p = FALSE;
 442                 }
 443             }
 444           break;
 445
 446         case DATA_SEGMENT_RELRO_END:
 447           expld.dataseg.relro = exp_dataseg_relro_end;
 448           if (expld.phase == lang_first_phase_enum
 449               || expld.section != bfd_abs_section_ptr)
 450             expld.result.valid_p = FALSE;
 451           else if (expld.dataseg.phase == exp_dataseg_align_seen
 452                    || expld.dataseg.phase == exp_dataseg_adjust
 453                    || expld.dataseg.phase == exp_dataseg_relro_adjust
 454                    || expld.dataseg.phase == exp_dataseg_done)
 455             {
 456               if (expld.dataseg.phase == exp_dataseg_align_seen
 457                   || expld.dataseg.phase == exp_dataseg_relro_adjust)
 458                 expld.dataseg.relro_end = lhs.value + expld.result.value;
 459
 460               if (expld.dataseg.phase == exp_dataseg_relro_adjust
 461                   && (expld.dataseg.relro_end
 462                       & (expld.dataseg.pagesize - 1)))
 463                 {
 464                   expld.dataseg.relro_end += expld.dataseg.pagesize - 1;
 465                   expld.dataseg.relro_end &= ~(expld.dataseg.pagesize - 1);
 466                   expld.result.value = (expld.dataseg.relro_end
 467                                         - expld.result.value);
 468                 }
 469               else
 470                 expld.result.value = lhs.value;
 471
 472               if (expld.dataseg.phase == exp_dataseg_align_seen)
 473                 expld.dataseg.phase = exp_dataseg_relro_seen;
 474             }
 475           else
 476             expld.result.valid_p = FALSE;
 477           break;
 478
 479         default:
 480           FAIL ();
 481         }
 482     }
 483 }
 484
 485 static void
 486 fold_trinary (etree_type *tree)
 487 {
 488   exp_fold_tree_1 (tree->trinary.cond);
 489   if (expld.result.valid_p)
 490     exp_fold_tree_1 (expld.result.value
 491                      ? tree->trinary.lhs
 492                      : tree->trinary.rhs);
 493 }
 494
 495 static void
 496 fold_name (etree_type *tree)
 497 {
 498   memset (&expld.result, 0, sizeof (expld.result));
 499
 500   switch (tree->type.node_code)
 501     {
 502     case SIZEOF_HEADERS:
 503       if (expld.phase != lang_first_phase_enum)
 504         {
 505           bfd_vma hdr_size = 0;
 506           /* Don't find the real header size if only marking sections;
 507              The bfd function may cache incorrect data.  */
 508           if (expld.phase != lang_mark_phase_enum)
 509             hdr_size = bfd_sizeof_headers (link_info.output_bfd, &link_info);
 510           new_number (hdr_size);
 511         }
 512       break;
 513
 514     case DEFINED:
 515       if (expld.phase == lang_first_phase_enum)
 516         lang_track_definedness (tree->name.name);
 517       else
 518         {
 519           struct bfd_link_hash_entry *h;
 520           int def_iteration
 521             = lang_symbol_definition_iteration (tree->name.name);
 522
 523           h = bfd_wrapped_link_hash_lookup (link_info.output_bfd,
 524                                             &link_info,
 525                                             tree->name.name,
 526                                             FALSE, FALSE, TRUE);
 527           new_number (h != NULL
 528                       && (h->type == bfd_link_hash_defined
 529                           || h->type == bfd_link_hash_defweak
 530                           || h->type == bfd_link_hash_common)
 531                       && (def_iteration == lang_statement_iteration
 532                           || def_iteration == -1));
 533         }
 534       break;
 535
 536     case NAME:
 537       if (expld.phase == lang_first_phase_enum)
 538         ;
 539       else if (tree->name.name[0] == '.' && tree->name.name[1] == 0)
 540         new_rel_from_abs (expld.dot);
 541       else
 542         {
 543           struct bfd_link_hash_entry *h;
 544
 545           h = bfd_wrapped_link_hash_lookup (link_info.output_bfd,
 546                                             &link_info,
 547                                             tree->name.name,
 548                                             TRUE, FALSE, TRUE);
 549           if (!h)
 550             einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
 551           else if (h->type == bfd_link_hash_defined
 552                    || h->type == bfd_link_hash_defweak)
 553             {
 554               asection *output_section;
 555
 556               output_section = h->u.def.section->output_section;
 557               if (output_section == NULL)
 558                 {
 559                   if (expld.phase != lang_mark_phase_enum)
 560                     einfo (_("%X%S: unresolvable symbol `%s'"
 561                              " referenced in expression\n"),
 562                            tree->name.name);
 563                 }
 564               else if (output_section == bfd_abs_section_ptr
 565                        && (expld.section != bfd_abs_section_ptr
 566                            || config.sane_expr))
 567                 new_number (h->u.def.value + h->u.def.section->output_offset);
 568               else
 569                 new_rel (h->u.def.value + h->u.def.section->output_offset,
 570                          output_section);
 571             }
 572           else if (expld.phase == lang_final_phase_enum
 573                    || expld.assigning_to_dot)
 574             einfo (_("%F%S: undefined symbol `%s' referenced in expression\n"),
 575                    tree->name.name);
 576           else if (h->type == bfd_link_hash_new)
 577             {
 578               h->type = bfd_link_hash_undefined;
 579               h->u.undef.abfd = NULL;
 580               if (h->u.undef.next == NULL && h != link_info.hash->undefs_tail)
 581                 bfd_link_add_undef (link_info.hash, h);
 582             }
 583         }
 584       break;
 585
 586     case ADDR:
 587       if (expld.phase != lang_first_phase_enum)
 588         {
 589           lang_output_section_statement_type *os;
 590
 591           os = lang_output_section_find (tree->name.name);
 592           if (os == NULL)
 593             {
 594               if (expld.phase == lang_final_phase_enum)
 595                 einfo (_("%F%S: undefined section `%s' referenced in expression\n"),
 596                        tree->name.name);
 597             }
 598           else if (os->processed_vma)
 599             new_rel (0, os->bfd_section);
 600         }
 601       break;
 602
 603     case LOADADDR:
 604       if (expld.phase != lang_first_phase_enum)
 605         {
 606           lang_output_section_statement_type *os;
 607
 608           os = lang_output_section_find (tree->name.name);
 609           if (os == NULL)
 610             {
 611               if (expld.phase == lang_final_phase_enum)
 612                 einfo (_("%F%S: undefined section `%s' referenced in expression\n"),
 613                        tree->name.name);
 614             }
 615           else if (os->processed_lma)
 616             {
 617               if (os->load_base == NULL)
 618                 new_abs (os->bfd_section->lma);
 619               else
 620                 {
 621                   exp_fold_tree_1 (os->load_base);
 622                   if (expld.result.valid_p)
 623                     make_abs ();
 624                 }
 625             }
 626         }
 627       break;
 628
 629     case SIZEOF:
 630     case ALIGNOF:
 631       if (expld.phase != lang_first_phase_enum)
 632         {
 633           lang_output_section_statement_type *os;
 634
 635           os = lang_output_section_find (tree->name.name);
 636           if (os == NULL)
 637             {
 638               if (expld.phase == lang_final_phase_enum)
 639                 einfo (_("%F%S: undefined section `%s' referenced in expression\n"),
 640                        tree->name.name);
 641               new_number (0);
 642             }
 643           else if (os->processed_vma)
 644             {
 645               bfd_vma val;
 646
 647               if (tree->type.node_code == SIZEOF)
 648                 val = (os->bfd_section->size
 649                        / bfd_octets_per_byte (link_info.output_bfd));
 650               else
 651                 val = (bfd_vma)1 << os->bfd_section->alignment_power;
 652
 653               new_number (val);
 654             }
 655         }
 656       break;
 657
 658     case LENGTH:
 659       {
 660         lang_memory_region_type *mem;
 661
 662         mem = lang_memory_region_lookup (tree->name.name, FALSE);
 663         if (mem != NULL)
 664           new_number (mem->length);
 665         else
 666           einfo (_("%F%S: undefined MEMORY region `%s'"
 667                    " referenced in expression\n"), tree->name.name);
 668       }
 669       break;
 670
 671     case ORIGIN:
 672       if (expld.phase != lang_first_phase_enum)
 673         {
 674           lang_memory_region_type *mem;
 675
 676           mem = lang_memory_region_lookup (tree->name.name, FALSE);
 677           if (mem != NULL)
 678             new_rel_from_abs (mem->origin);
 679           else
 680             einfo (_("%F%S: undefined MEMORY region `%s'"
 681                      " referenced in expression\n"), tree->name.name);
 682         }
 683       break;
 684
 685     case CONSTANT:
 686       if (strcmp (tree->name.name, "MAXPAGESIZE") == 0)
 687         new_number (config.maxpagesize);
 688       else if (strcmp (tree->name.name, "COMMONPAGESIZE") == 0)
 689         new_number (config.commonpagesize);
 690       else
 691         einfo (_("%F%S: unknown constant `%s' referenced in expression\n"),
 692                tree->name.name);
 693       break;
 694
 695     default:
 696       FAIL ();
 697       break;
 698     }
 699 }
 700
 701 static void
 702 exp_fold_tree_1 (etree_type *tree)
 703 {
 704   if (tree == NULL)
 705     {
 706       memset (&expld.result, 0, sizeof (expld.result));
 707       return;
 708     }
 709
 710   switch (tree->type.node_class)
 711     {
 712     case etree_value:
 713       if (expld.section == bfd_abs_section_ptr
 714           && !config.sane_expr)
 715         new_abs (tree->value.value);
 716       else
 717         new_number (tree->value.value);
 718       expld.result.str = tree->value.str;
 719       break;
 720
 721     case etree_rel:
 722       if (expld.phase != lang_first_phase_enum)
 723         {
 724           asection *output_section = tree->rel.section->output_section;
 725           new_rel (tree->rel.value + tree->rel.section->output_offset,
 726                    output_section);
 727         }
 728       else
 729         memset (&expld.result, 0, sizeof (expld.result));
 730       break;
 731
 732     case etree_assert:
 733       exp_fold_tree_1 (tree->assert_s.child);
 734       if (expld.phase == lang_final_phase_enum && !expld.result.value)
 735         einfo ("%X%P: %s\n", tree->assert_s.message);
 736       break;
 737
 738     case etree_unary:
 739       fold_unary (tree);
 740       break;
 741
 742     case etree_binary:
 743       fold_binary (tree);
 744       break;
 745
 746     case etree_trinary:
 747       fold_trinary (tree);
 748       break;
 749
 750     case etree_assign:
 751     case etree_provide:
 752     case etree_provided:
 753       if (tree->assign.dst[0] == '.' && tree->assign.dst[1] == 0)
 754         {
 755           /* Assignment to dot can only be done during allocation.  */
 756           if (tree->type.node_class != etree_assign)
 757             einfo (_("%F%S can not PROVIDE assignment to location counter\n"));
 758           if (expld.phase == lang_mark_phase_enum
 759               || expld.phase == lang_allocating_phase_enum
 760               || (expld.phase == lang_final_phase_enum
 761                   && expld.section == bfd_abs_section_ptr))
 762             {
 763               /* Notify the folder that this is an assignment to dot.  */
 764               expld.assigning_to_dot = TRUE;
 765               exp_fold_tree_1 (tree->assign.src);
 766               expld.assigning_to_dot = FALSE;
 767
 768               if (!expld.result.valid_p)
 769                 {
 770                   if (expld.phase != lang_mark_phase_enum)
 771                     einfo (_("%F%S invalid assignment to location counter\n"));
 772                 }
 773               else if (expld.dotp == NULL)
 774                 einfo (_("%F%S assignment to location counter"
 775                          " invalid outside of SECTION\n"));
 776               else
 777                 {
 778                   bfd_vma nextdot;
 779
 780                   nextdot = expld.result.value;
 781                   if (expld.result.section != NULL)
 782                     nextdot += expld.result.section->vma;
 783                   else
 784                     nextdot += expld.section->vma;
 785                   if (nextdot < expld.dot
 786                       && expld.section != bfd_abs_section_ptr)
 787                     einfo (_("%F%S cannot move location counter backwards"
 788                              " (from %V to %V)\n"), expld.dot, nextdot);
 789                   else
 790                     {
 791                       expld.dot = nextdot;
 792                       *expld.dotp = nextdot;
 793                     }
 794                 }
 795             }
 796           else
 797             memset (&expld.result, 0, sizeof (expld.result));
 798         }
 799       else
 800         {
 801           struct bfd_link_hash_entry *h = NULL;
 802
 803           if (tree->type.node_class == etree_provide)
 804             {
 805               h = bfd_link_hash_lookup (link_info.hash, tree->assign.dst,
 806                                         FALSE, FALSE, TRUE);
 807               if (h == NULL
 808                   || (h->type != bfd_link_hash_new
 809                       && h->type != bfd_link_hash_undefined
 810                       && h->type != bfd_link_hash_common))
 811                 {
 812                   /* Do nothing.  The symbol was never referenced, or was
 813                      defined by some object.  */
 814                   break;
 815                 }
 816             }
 817
 818           exp_fold_tree_1 (tree->assign.src);
 819           if (expld.result.valid_p
 820               || (expld.phase == lang_first_phase_enum
 821                   && tree->type.node_class == etree_assign
 822                   && tree->assign.hidden))
 823             {
 824               if (h == NULL)
 825                 {
 826                   h = bfd_link_hash_lookup (link_info.hash, tree->assign.dst,
 827                                             TRUE, FALSE, TRUE);
 828                   if (h == NULL)
 829                     einfo (_("%P%F:%s: hash creation failed\n"),
 830                            tree->assign.dst);
 831                 }
 832
 833               /* FIXME: Should we worry if the symbol is already
 834                  defined?  */
 835               lang_update_definedness (tree->assign.dst, h);
 836               h->type = bfd_link_hash_defined;
 837               h->u.def.value = expld.result.value;
 838               if (expld.result.section == NULL)
 839                 expld.result.section = expld.section;
 840               h->u.def.section = expld.result.section;
 841               if (tree->type.node_class == etree_provide)
 842                 tree->type.node_class = etree_provided;
 843
 844               /* Copy the symbol type if this is a simple assignment of
 845                  one symbol to annother.  */
 846               if (tree->assign.src->type.node_class == etree_name)
 847                 {
 848                   struct bfd_link_hash_entry *hsrc;
 849
 850                   hsrc = bfd_link_hash_lookup (link_info.hash,
 851                                                tree->assign.src->name.name,
 852                                                FALSE, FALSE, TRUE);
 853                   if (hsrc)
 854                     bfd_copy_link_hash_symbol_type (link_info.output_bfd, h,
 855                                                     hsrc);
 856                 }
 857             }
 858           else if (expld.phase == lang_final_phase_enum)
 859             {
 860               h = bfd_link_hash_lookup (link_info.hash, tree->assign.dst,
 861                                         FALSE, FALSE, TRUE);
 862               if (h != NULL
 863                   && h->type == bfd_link_hash_new)
 864                 h->type = bfd_link_hash_undefined;
 865             }
 866         }
 867       break;
 868
 869     case etree_name:
 870       fold_name (tree);
 871       break;
 872
 873     default:
 874       FAIL ();
 875       memset (&expld.result, 0, sizeof (expld.result));
 876       break;
 877     }
 878 }
 879
 880 void
 881 exp_fold_tree (etree_type *tree, asection *current_section, bfd_vma *dotp)
 882 {
 883   expld.dot = *dotp;
 884   expld.dotp = dotp;
 885   expld.section = current_section;
 886   exp_fold_tree_1 (tree);
 887 }
 888
 889 void
 890 exp_fold_tree_no_dot (etree_type *tree)
 891 {
 892   expld.dot = 0;
 893   expld.dotp = NULL;
 894   expld.section = bfd_abs_section_ptr;
 895   exp_fold_tree_1 (tree);
 896 }
 897
 898 etree_type *
 899 exp_binop (int code, etree_type *lhs, etree_type *rhs)
 900 {
 901   etree_type value, *new_e;
 902
 903   value.type.node_code = code;
 904   value.type.lineno = lhs->type.lineno;
 905   value.binary.lhs = lhs;
 906   value.binary.rhs = rhs;
 907   value.type.node_class = etree_binary;
 908   exp_fold_tree_no_dot (&value);
 909   if (expld.result.valid_p)
 910     return exp_intop (expld.result.value);
 911
 912   new_e = (etree_type *) stat_alloc (sizeof (new_e->binary));
 913   memcpy (new_e, &value, sizeof (new_e->binary));
 914   return new_e;
 915 }
 916
 917 etree_type *
 918 exp_trinop (int code, etree_type *cond, etree_type *lhs, etree_type *rhs)
 919 {
 920   etree_type value, *new_e;
 921
 922   value.type.node_code = code;
 923   value.type.lineno = lhs->type.lineno;
 924   value.trinary.lhs = lhs;
 925   value.trinary.cond = cond;
 926   value.trinary.rhs = rhs;
 927   value.type.node_class = etree_trinary;
 928   exp_fold_tree_no_dot (&value);
 929   if (expld.result.valid_p)
 930     return exp_intop (expld.result.value);
 931
 932   new_e = (etree_type *) stat_alloc (sizeof (new_e->trinary));
 933   memcpy (new_e, &value, sizeof (new_e->trinary));
 934   return new_e;
 935 }
 936
 937 etree_type *
 938 exp_unop (int code, etree_type *child)
 939 {
 940   etree_type value, *new_e;
 941
 942   value.unary.type.node_code = code;
 943   value.unary.type.lineno = child->type.lineno;
 944   value.unary.child = child;
 945   value.unary.type.node_class = etree_unary;
 946   exp_fold_tree_no_dot (&value);
 947   if (expld.result.valid_p)
 948     return exp_intop (expld.result.value);
 949
 950   new_e = (etree_type *) stat_alloc (sizeof (new_e->unary));
 951   memcpy (new_e, &value, sizeof (new_e->unary));
 952   return new_e;
 953 }
 954
 955 etree_type *
 956 exp_nameop (int code, const char *name)
 957 {
 958   etree_type value, *new_e;
 959
 960   value.name.type.node_code = code;
 961   value.name.type.lineno = lineno;
 962   value.name.name = name;
 963   value.name.type.node_class = etree_name;
 964
 965   exp_fold_tree_no_dot (&value);
 966   if (expld.result.valid_p)
 967     return exp_intop (expld.result.value);
 968
 969   new_e = (etree_type *) stat_alloc (sizeof (new_e->name));
 970   memcpy (new_e, &value, sizeof (new_e->name));
 971   return new_e;
 972
 973 }
 974
 975 static etree_type *
 976 exp_assop (const char *dst,
 977            etree_type *src,
 978            enum node_tree_enum class,
 979            bfd_boolean hidden)
 980 {
 981   etree_type *n;
 982
 983   n = (etree_type *) stat_alloc (sizeof (n->assign));
 984   n->assign.type.node_code = '=';
 985   n->assign.type.lineno = src->type.lineno;
 986   n->assign.type.node_class = class;
 987   n->assign.src = src;
 988   n->assign.dst = dst;
 989   n->assign.hidden = hidden;
 990   return n;
 991 }
 992
 993 etree_type *
 994 exp_assign (const char *dst, etree_type *src)
 995 {
 996   return exp_assop (dst, src, etree_assign, FALSE);
 997 }
 998
 999 etree_type *
1000 exp_defsym (const char *dst, etree_type *src)
1001 {
1002   return exp_assop (dst, src, etree_assign, TRUE);
1003 }
1004
1005 /* Handle PROVIDE.  */
1006
1007 etree_type *
1008 exp_provide (const char *dst, etree_type *src, bfd_boolean hidden)
1009 {
1010   return exp_assop (dst, src, etree_provide, hidden);
1011 }
1012
1013 /* Handle ASSERT.  */
1014
1015 etree_type *
1016 exp_assert (etree_type *exp, const char *message)
1017 {
1018   etree_type *n;
1019
1020   n = (etree_type *) stat_alloc (sizeof (n->assert_s));
1021   n->assert_s.type.node_code = '!';
1022   n->assert_s.type.lineno = exp->type.lineno;
1023   n->assert_s.type.node_class = etree_assert;
1024   n->assert_s.child = exp;
1025   n->assert_s.message = message;
1026   return n;
1027 }
1028
1029 void
1030 exp_print_tree (etree_type *tree)
1031 {
1032   bfd_boolean function_like;
1033
1034   if (config.map_file == NULL)
1035     config.map_file = stderr;
1036
1037   if (tree == NULL)
1038     {
1039       minfo ("NULL TREE\n");
1040       return;
1041     }
1042
1043   switch (tree->type.node_class)
1044     {
1045     case etree_value:
1046       minfo ("0x%v", tree->value.value);
1047       return;
1048     case etree_rel:
1049       if (tree->rel.section->owner != NULL)
1050         minfo ("%B:", tree->rel.section->owner);
1051       minfo ("%s+0x%v", tree->rel.section->name, tree->rel.value);
1052       return;
1053     case etree_assign:
1054       fputs (tree->assign.dst, config.map_file);
1055       exp_print_token (tree->type.node_code, TRUE);
1056       exp_print_tree (tree->assign.src);
1057       break;
1058     case etree_provide:
1059     case etree_provided:
1060       fprintf (config.map_file, "PROVIDE (%s, ", tree->assign.dst);
1061       exp_print_tree (tree->assign.src);
1062       fputc (')', config.map_file);
1063       break;
1064     case etree_binary:
1065       function_like = FALSE;
1066       switch (tree->type.node_code)
1067         {
1068         case MAX_K:
1069         case MIN_K:
1070         case ALIGN_K:
1071         case DATA_SEGMENT_ALIGN:
1072         case DATA_SEGMENT_RELRO_END:
1073           function_like = TRUE;
1074         }
1075       if (function_like)
1076         {
1077           exp_print_token (tree->type.node_code, FALSE);
1078           fputc (' ', config.map_file);
1079         }
1080       fputc ('(', config.map_file);
1081       exp_print_tree (tree->binary.lhs);
1082       if (function_like)
1083         fprintf (config.map_file, ", ");
1084       else
1085         exp_print_token (tree->type.node_code, TRUE);
1086       exp_print_tree (tree->binary.rhs);
1087       fputc (')', config.map_file);
1088       break;
1089     case etree_trinary:
1090       exp_print_tree (tree->trinary.cond);
1091       fputc ('?', config.map_file);
1092       exp_print_tree (tree->trinary.lhs);
1093       fputc (':', config.map_file);
1094       exp_print_tree (tree->trinary.rhs);
1095       break;
1096     case etree_unary:
1097       exp_print_token (tree->unary.type.node_code, FALSE);
1098       if (tree->unary.child)
1099         {
1100           fprintf (config.map_file, " (");
1101           exp_print_tree (tree->unary.child);
1102           fputc (')', config.map_file);
1103         }
1104       break;
1105
1106     case etree_assert:
1107       fprintf (config.map_file, "ASSERT (");
1108       exp_print_tree (tree->assert_s.child);
1109       fprintf (config.map_file, ", %s)", tree->assert_s.message);
1110       break;
1111
1112     case etree_name:
1113       if (tree->type.node_code == NAME)
1114         fputs (tree->name.name, config.map_file);
1115       else
1116         {
1117           exp_print_token (tree->type.node_code, FALSE);
1118           if (tree->name.name)
1119             fprintf (config.map_file, " (%s)", tree->name.name);
1120         }
1121       break;
1122     default:
1123       FAIL ();
1124       break;
1125     }
1126 }
1127
1128 bfd_vma
1129 exp_get_vma (etree_type *tree, bfd_vma def, char *name)
1130 {
1131   if (tree != NULL)
1132     {
1133       exp_fold_tree_no_dot (tree);
1134       if (expld.result.valid_p)
1135         return expld.result.value;
1136       else if (name != NULL && expld.phase != lang_mark_phase_enum)
1137         einfo (_("%F%S: nonconstant expression for %s\n"), name);
1138     }
1139   return def;
1140 }
1141
1142 int
1143 exp_get_value_int (etree_type *tree, int def, char *name)
1144 {
1145   return exp_get_vma (tree, def, name);
1146 }
1147
1148 fill_type *
1149 exp_get_fill (etree_type *tree, fill_type *def, char *name)
1150 {
1151   fill_type *fill;
1152   size_t len;
1153   unsigned int val;
1154
1155   if (tree == NULL)
1156     return def;
1157
1158   exp_fold_tree_no_dot (tree);
1159   if (!expld.result.valid_p)
1160     {
1161       if (name != NULL && expld.phase != lang_mark_phase_enum)
1162         einfo (_("%F%S: nonconstant expression for %s\n"), name);
1163       return def;
1164     }
1165
1166   if (expld.result.str != NULL && (len = strlen (expld.result.str)) != 0)
1167     {
1168       unsigned char *dst;
1169       unsigned char *s;
1170       fill = (fill_type *) xmalloc ((len + 1) / 2 + sizeof (*fill) - 1);
1171       fill->size = (len + 1) / 2;
1172       dst = fill->data;
1173       s = (unsigned char *) expld.result.str;
1174       val = 0;
1175       do
1176         {
1177           unsigned int digit;
1178
1179           digit = *s++ - '0';
1180           if (digit > 9)
1181             digit = (digit - 'A' + '0' + 10) & 0xf;
1182           val <<= 4;
1183           val += digit;
1184           --len;
1185           if ((len & 1) == 0)
1186             {
1187               *dst++ = val;
1188               val = 0;
1189             }
1190         }
1191       while (len != 0);
1192     }
1193   else
1194     {
1195       fill = (fill_type *) xmalloc (4 + sizeof (*fill) - 1);
1196       val = expld.result.value;
1197       fill->data[0] = (val >> 24) & 0xff;
1198       fill->data[1] = (val >> 16) & 0xff;
1199       fill->data[2] = (val >>  8) & 0xff;
1200       fill->data[3] = (val >>  0) & 0xff;
1201       fill->size = 4;
1202     }
1203   return fill;
1204 }
1205
1206 bfd_vma
1207 exp_get_abs_int (etree_type *tree, int def, char *name)
1208 {
1209   if (tree != NULL)
1210     {
1211       exp_fold_tree_no_dot (tree);
1212
1213       if (expld.result.valid_p)
1214         {
1215           if (expld.result.section != NULL)
1216             expld.result.value += expld.result.section->vma;
1217           return expld.result.value;
1218         }
1219       else if (name != NULL && expld.phase != lang_mark_phase_enum)
1220         {
1221           lineno = tree->type.lineno;
1222           einfo (_("%F%S: nonconstant expression for %s\n"), name);
1223         }
1224     }
1225   return def;
1226 }
1227
1228 static bfd_vma
1229 align_n (bfd_vma value, bfd_vma align)
1230 {
1231   if (align <= 1)
1232     return value;
1233
1234   value = (value + align - 1) / align;
1235   return value * align;
1236 }