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