Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | RSS feed

  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.         lang_track_definedness (tree->name.name);
  580.       else
  581.         {
  582.           struct bfd_link_hash_entry *h;
  583.           int def_iteration
  584.             = lang_symbol_definition_iteration (tree->name.name);
  585.  
  586.           h = bfd_wrapped_link_hash_lookup (link_info.output_bfd,
  587.                                             &link_info,
  588.                                             tree->name.name,
  589.                                             FALSE, FALSE, TRUE);
  590.           new_number (h != NULL
  591.                       && (h->type == bfd_link_hash_defined
  592.                           || h->type == bfd_link_hash_defweak
  593.                           || h->type == bfd_link_hash_common)
  594.                       && (def_iteration == lang_statement_iteration
  595.                           || def_iteration == -1));
  596.         }
  597.       break;
  598.  
  599.     case NAME:
  600.       if (expld.assign_name != NULL
  601.           && strcmp (expld.assign_name, tree->name.name) == 0)
  602.         expld.assign_name = NULL;
  603.       if (expld.phase == lang_first_phase_enum)
  604.         ;
  605.       else if (tree->name.name[0] == '.' && tree->name.name[1] == 0)
  606.         new_rel_from_abs (expld.dot);
  607.       else
  608.         {
  609.           struct bfd_link_hash_entry *h;
  610.  
  611.           h = bfd_wrapped_link_hash_lookup (link_info.output_bfd,
  612.                                             &link_info,
  613.                                             tree->name.name,
  614.                                             TRUE, FALSE, TRUE);
  615.           if (!h)
  616.             einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
  617.           else if (h->type == bfd_link_hash_defined
  618.                    || h->type == bfd_link_hash_defweak)
  619.             {
  620.               asection *output_section;
  621.  
  622.               output_section = h->u.def.section->output_section;
  623.               if (output_section == NULL)
  624.                 {
  625.                   if (expld.phase == lang_mark_phase_enum)
  626.                     new_rel (h->u.def.value, h->u.def.section);
  627.                   else
  628.                     einfo (_("%X%S: unresolvable symbol `%s'"
  629.                              " referenced in expression\n"),
  630.                            tree, tree->name.name);
  631.                 }
  632.               else if (output_section == bfd_abs_section_ptr
  633.                        && (expld.section != bfd_abs_section_ptr
  634.                            || config.sane_expr))
  635.                 new_number (h->u.def.value + h->u.def.section->output_offset);
  636.               else
  637.                 new_rel (h->u.def.value + h->u.def.section->output_offset,
  638.                          output_section);
  639.             }
  640.           else if (expld.phase == lang_final_phase_enum
  641.                    || (expld.phase != lang_mark_phase_enum
  642.                        && expld.assigning_to_dot))
  643.             einfo (_("%F%S: undefined symbol `%s'"
  644.                      " referenced in expression\n"),
  645.                    tree, tree->name.name);
  646.           else if (h->type == bfd_link_hash_new)
  647.             {
  648.               h->type = bfd_link_hash_undefined;
  649.               h->u.undef.abfd = NULL;
  650.               if (h->u.undef.next == NULL && h != link_info.hash->undefs_tail)
  651.                 bfd_link_add_undef (link_info.hash, h);
  652.             }
  653.         }
  654.       break;
  655.  
  656.     case ADDR:
  657.       if (expld.phase != lang_first_phase_enum)
  658.         {
  659.           lang_output_section_statement_type *os;
  660.  
  661.           os = lang_output_section_find (tree->name.name);
  662.           if (os == NULL)
  663.             {
  664.               if (expld.phase == lang_final_phase_enum)
  665.                 einfo (_("%F%S: undefined section `%s'"
  666.                          " referenced in expression\n"),
  667.                        tree, tree->name.name);
  668.             }
  669.           else if (os->processed_vma)
  670.             new_rel (0, os->bfd_section);
  671.         }
  672.       break;
  673.  
  674.     case LOADADDR:
  675.       if (expld.phase != lang_first_phase_enum)
  676.         {
  677.           lang_output_section_statement_type *os;
  678.  
  679.           os = lang_output_section_find (tree->name.name);
  680.           if (os == NULL)
  681.             {
  682.               if (expld.phase == lang_final_phase_enum)
  683.                 einfo (_("%F%S: undefined section `%s'"
  684.                          " referenced in expression\n"),
  685.                        tree, tree->name.name);
  686.             }
  687.           else if (os->processed_lma)
  688.             {
  689.               if (os->load_base == NULL)
  690.                 new_abs (os->bfd_section->lma);
  691.               else
  692.                 {
  693.                   exp_fold_tree_1 (os->load_base);
  694.                   if (expld.result.valid_p)
  695.                     make_abs ();
  696.                 }
  697.             }
  698.         }
  699.       break;
  700.  
  701.     case SIZEOF:
  702.     case ALIGNOF:
  703.       if (expld.phase != lang_first_phase_enum)
  704.         {
  705.           lang_output_section_statement_type *os;
  706.  
  707.           os = lang_output_section_find (tree->name.name);
  708.           if (os == NULL)
  709.             {
  710.               if (expld.phase == lang_final_phase_enum)
  711.                 einfo (_("%F%S: undefined section `%s'"
  712.                          " referenced in expression\n"),
  713.                        tree, tree->name.name);
  714.               new_number (0);
  715.             }
  716.           else if (os->bfd_section != NULL)
  717.             {
  718.               bfd_vma val;
  719.  
  720.               if (tree->type.node_code == SIZEOF)
  721.                 val = (os->bfd_section->size
  722.                        / bfd_octets_per_byte (link_info.output_bfd));
  723.               else
  724.                 val = (bfd_vma)1 << os->bfd_section->alignment_power;
  725.  
  726.               new_number (val);
  727.             }
  728.           else
  729.             new_number (0);
  730.         }
  731.       break;
  732.  
  733.     case LENGTH:
  734.       {
  735.         lang_memory_region_type *mem;
  736.  
  737.         mem = lang_memory_region_lookup (tree->name.name, FALSE);
  738.         if (mem != NULL)
  739.           new_number (mem->length);
  740.         else
  741.           einfo (_("%F%S: undefined MEMORY region `%s'"
  742.                    " referenced in expression\n"),
  743.                  tree, tree->name.name);
  744.       }
  745.       break;
  746.  
  747.     case ORIGIN:
  748.       if (expld.phase != lang_first_phase_enum)
  749.         {
  750.           lang_memory_region_type *mem;
  751.  
  752.           mem = lang_memory_region_lookup (tree->name.name, FALSE);
  753.           if (mem != NULL)
  754.             new_rel_from_abs (mem->origin);
  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 CONSTANT:
  763.       if (strcmp (tree->name.name, "MAXPAGESIZE") == 0)
  764.         new_number (config.maxpagesize);
  765.       else if (strcmp (tree->name.name, "COMMONPAGESIZE") == 0)
  766.         new_number (config.commonpagesize);
  767.       else
  768.         einfo (_("%F%S: unknown constant `%s' referenced in expression\n"),
  769.                tree, tree->name.name);
  770.       break;
  771.  
  772.     default:
  773.       FAIL ();
  774.       break;
  775.     }
  776. }
  777.  
  778. static void
  779. exp_fold_tree_1 (etree_type *tree)
  780. {
  781.   if (tree == NULL)
  782.     {
  783.       memset (&expld.result, 0, sizeof (expld.result));
  784.       return;
  785.     }
  786.  
  787.   switch (tree->type.node_class)
  788.     {
  789.     case etree_value:
  790.       if (expld.section == bfd_abs_section_ptr
  791.           && !config.sane_expr)
  792.         new_abs (tree->value.value);
  793.       else
  794.         new_number (tree->value.value);
  795.       expld.result.str = tree->value.str;
  796.       break;
  797.  
  798.     case etree_rel:
  799.       if (expld.phase != lang_first_phase_enum)
  800.         {
  801.           asection *output_section = tree->rel.section->output_section;
  802.           new_rel (tree->rel.value + tree->rel.section->output_offset,
  803.                    output_section);
  804.         }
  805.       else
  806.         memset (&expld.result, 0, sizeof (expld.result));
  807.       break;
  808.  
  809.     case etree_assert:
  810.       exp_fold_tree_1 (tree->assert_s.child);
  811.       if (expld.phase == lang_final_phase_enum && !expld.result.value)
  812.         einfo ("%X%P: %s\n", tree->assert_s.message);
  813.       break;
  814.  
  815.     case etree_unary:
  816.       fold_unary (tree);
  817.       break;
  818.  
  819.     case etree_binary:
  820.       fold_binary (tree);
  821.       break;
  822.  
  823.     case etree_trinary:
  824.       fold_trinary (tree);
  825.       break;
  826.  
  827.     case etree_assign:
  828.     case etree_provide:
  829.     case etree_provided:
  830.       if (tree->assign.dst[0] == '.' && tree->assign.dst[1] == 0)
  831.         {
  832.           if (tree->type.node_class != etree_assign)
  833.             einfo (_("%F%S can not PROVIDE assignment to"
  834.                      " location counter\n"), tree);
  835.           if (expld.phase != lang_first_phase_enum)
  836.             {
  837.               /* Notify the folder that this is an assignment to dot.  */
  838.               expld.assigning_to_dot = TRUE;
  839.               exp_fold_tree_1 (tree->assign.src);
  840.               expld.assigning_to_dot = FALSE;
  841.  
  842.               if (!expld.result.valid_p)
  843.                 {
  844.                   if (expld.phase != lang_mark_phase_enum)
  845.                     einfo (_("%F%S invalid assignment to"
  846.                              " location counter\n"), tree);
  847.                 }
  848.               else if (expld.dotp == NULL)
  849.                 einfo (_("%F%S assignment to location counter"
  850.                          " invalid outside of SECTIONS\n"), tree);
  851.  
  852.               /* After allocation, assignment to dot should not be
  853.                  done inside an output section since allocation adds a
  854.                  padding statement that effectively duplicates the
  855.                  assignment.  */
  856.               else if (expld.phase <= lang_allocating_phase_enum
  857.                        || expld.section == bfd_abs_section_ptr)
  858.                 {
  859.                   bfd_vma nextdot;
  860.  
  861.                   nextdot = expld.result.value;
  862.                   if (expld.result.section != NULL)
  863.                     nextdot += expld.result.section->vma;
  864.                   else
  865.                     nextdot += expld.section->vma;
  866.                   if (nextdot < expld.dot
  867.                       && expld.section != bfd_abs_section_ptr)
  868.                     einfo (_("%F%S cannot move location counter backwards"
  869.                              " (from %V to %V)\n"),
  870.                            tree, expld.dot, nextdot);
  871.                   else
  872.                     {
  873.                       expld.dot = nextdot;
  874.                       *expld.dotp = nextdot;
  875.                     }
  876.                 }
  877.             }
  878.           else
  879.             memset (&expld.result, 0, sizeof (expld.result));
  880.         }
  881.       else
  882.         {
  883.           struct bfd_link_hash_entry *h = NULL;
  884.  
  885.           if (tree->type.node_class == etree_provide)
  886.             {
  887.               h = bfd_link_hash_lookup (link_info.hash, tree->assign.dst,
  888.                                         FALSE, FALSE, TRUE);
  889.               if (h == NULL
  890.                   || (h->type != bfd_link_hash_new
  891.                       && h->type != bfd_link_hash_undefined
  892.                       && h->type != bfd_link_hash_common))
  893.                 {
  894.                   /* Do nothing.  The symbol was never referenced, or was
  895.                      defined by some object.  */
  896.                   break;
  897.                 }
  898.             }
  899.  
  900.           expld.assign_name = tree->assign.dst;
  901.           exp_fold_tree_1 (tree->assign.src);
  902.           /* expld.assign_name remaining equal to tree->assign.dst
  903.              below indicates the evaluation of tree->assign.src did
  904.              not use the value of tree->assign.dst.  We don't allow
  905.              self assignment until the final phase for two reasons:
  906.              1) Expressions are evaluated multiple times.  With
  907.              relaxation, the number of times may vary.
  908.              2) Section relative symbol values cannot be correctly
  909.              converted to absolute values, as is required by many
  910.              expressions, until final section sizing is complete.  */
  911.           if ((expld.result.valid_p
  912.                && (expld.phase == lang_final_phase_enum
  913.                    || expld.assign_name != NULL))
  914.               || (expld.phase <= lang_mark_phase_enum
  915.                   && tree->type.node_class == etree_assign
  916.                   && tree->assign.defsym))
  917.             {
  918.               if (h == NULL)
  919.                 {
  920.                   h = bfd_link_hash_lookup (link_info.hash, tree->assign.dst,
  921.                                             TRUE, FALSE, TRUE);
  922.                   if (h == NULL)
  923.                     einfo (_("%P%F:%s: hash creation failed\n"),
  924.                            tree->assign.dst);
  925.                 }
  926.  
  927.               /* FIXME: Should we worry if the symbol is already
  928.                  defined?  */
  929.               lang_update_definedness (tree->assign.dst, h);
  930.               h->type = bfd_link_hash_defined;
  931.               h->u.def.value = expld.result.value;
  932.               if (expld.result.section == NULL)
  933.                 expld.result.section = expld.section;
  934.               h->u.def.section = expld.result.section;
  935.               if (tree->type.node_class == etree_provide)
  936.                 tree->type.node_class = etree_provided;
  937.  
  938.               /* Copy the symbol type if this is a simple assignment of
  939.                  one symbol to another.  This could be more general
  940.                  (e.g. a ?: operator with NAMEs in each branch).  */
  941.               if (tree->assign.src->type.node_class == etree_name)
  942.                 {
  943.                   struct bfd_link_hash_entry *hsrc;
  944.  
  945.                   hsrc = bfd_link_hash_lookup (link_info.hash,
  946.                                                tree->assign.src->name.name,
  947.                                                FALSE, FALSE, TRUE);
  948.                   if (hsrc)
  949.                     bfd_copy_link_hash_symbol_type (link_info.output_bfd, h,
  950.                                                     hsrc);
  951.                 }
  952.             }
  953.           else if (expld.phase == lang_final_phase_enum)
  954.             {
  955.               h = bfd_link_hash_lookup (link_info.hash, tree->assign.dst,
  956.                                         FALSE, FALSE, TRUE);
  957.               if (h != NULL
  958.                   && h->type == bfd_link_hash_new)
  959.                 h->type = bfd_link_hash_undefined;
  960.             }
  961.           expld.assign_name = NULL;
  962.         }
  963.       break;
  964.  
  965.     case etree_name:
  966.       fold_name (tree);
  967.       break;
  968.  
  969.     default:
  970.       FAIL ();
  971.       memset (&expld.result, 0, sizeof (expld.result));
  972.       break;
  973.     }
  974. }
  975.  
  976. void
  977. exp_fold_tree (etree_type *tree, asection *current_section, bfd_vma *dotp)
  978. {
  979.   expld.dot = *dotp;
  980.   expld.dotp = dotp;
  981.   expld.section = current_section;
  982.   exp_fold_tree_1 (tree);
  983. }
  984.  
  985. void
  986. exp_fold_tree_no_dot (etree_type *tree)
  987. {
  988.   expld.dot = 0;
  989.   expld.dotp = NULL;
  990.   expld.section = bfd_abs_section_ptr;
  991.   exp_fold_tree_1 (tree);
  992. }
  993.  
  994. etree_type *
  995. exp_binop (int code, etree_type *lhs, etree_type *rhs)
  996. {
  997.   etree_type value, *new_e;
  998.  
  999.   value.type.node_code = code;
  1000.   value.type.filename = lhs->type.filename;
  1001.   value.type.lineno = lhs->type.lineno;
  1002.   value.binary.lhs = lhs;
  1003.   value.binary.rhs = rhs;
  1004.   value.type.node_class = etree_binary;
  1005.   exp_fold_tree_no_dot (&value);
  1006.   if (expld.result.valid_p)
  1007.     return exp_intop (expld.result.value);
  1008.  
  1009.   new_e = (etree_type *) stat_alloc (sizeof (new_e->binary));
  1010.   memcpy (new_e, &value, sizeof (new_e->binary));
  1011.   return new_e;
  1012. }
  1013.  
  1014. etree_type *
  1015. exp_trinop (int code, etree_type *cond, etree_type *lhs, etree_type *rhs)
  1016. {
  1017.   etree_type value, *new_e;
  1018.  
  1019.   value.type.node_code = code;
  1020.   value.type.filename = cond->type.filename;
  1021.   value.type.lineno = cond->type.lineno;
  1022.   value.trinary.lhs = lhs;
  1023.   value.trinary.cond = cond;
  1024.   value.trinary.rhs = rhs;
  1025.   value.type.node_class = etree_trinary;
  1026.   exp_fold_tree_no_dot (&value);
  1027.   if (expld.result.valid_p)
  1028.     return exp_intop (expld.result.value);
  1029.  
  1030.   new_e = (etree_type *) stat_alloc (sizeof (new_e->trinary));
  1031.   memcpy (new_e, &value, sizeof (new_e->trinary));
  1032.   return new_e;
  1033. }
  1034.  
  1035. etree_type *
  1036. exp_unop (int code, etree_type *child)
  1037. {
  1038.   etree_type value, *new_e;
  1039.  
  1040.   value.unary.type.node_code = code;
  1041.   value.unary.type.filename = child->type.filename;
  1042.   value.unary.type.lineno = child->type.lineno;
  1043.   value.unary.child = child;
  1044.   value.unary.type.node_class = etree_unary;
  1045.   exp_fold_tree_no_dot (&value);
  1046.   if (expld.result.valid_p)
  1047.     return exp_intop (expld.result.value);
  1048.  
  1049.   new_e = (etree_type *) stat_alloc (sizeof (new_e->unary));
  1050.   memcpy (new_e, &value, sizeof (new_e->unary));
  1051.   return new_e;
  1052. }
  1053.  
  1054. etree_type *
  1055. exp_nameop (int code, const char *name)
  1056. {
  1057.   etree_type value, *new_e;
  1058.  
  1059.   value.name.type.node_code = code;
  1060.   value.name.type.filename = ldlex_filename ();
  1061.   value.name.type.lineno = lineno;
  1062.   value.name.name = name;
  1063.   value.name.type.node_class = etree_name;
  1064.  
  1065.   exp_fold_tree_no_dot (&value);
  1066.   if (expld.result.valid_p)
  1067.     return exp_intop (expld.result.value);
  1068.  
  1069.   new_e = (etree_type *) stat_alloc (sizeof (new_e->name));
  1070.   memcpy (new_e, &value, sizeof (new_e->name));
  1071.   return new_e;
  1072.  
  1073. }
  1074.  
  1075. static etree_type *
  1076. exp_assop (const char *dst,
  1077.            etree_type *src,
  1078.            enum node_tree_enum class,
  1079.            bfd_boolean defsym,
  1080.            bfd_boolean hidden)
  1081. {
  1082.   etree_type *n;
  1083.  
  1084.   n = (etree_type *) stat_alloc (sizeof (n->assign));
  1085.   n->assign.type.node_code = '=';
  1086.   n->assign.type.filename = src->type.filename;
  1087.   n->assign.type.lineno = src->type.lineno;
  1088.   n->assign.type.node_class = class;
  1089.   n->assign.src = src;
  1090.   n->assign.dst = dst;
  1091.   n->assign.defsym = defsym;
  1092.   n->assign.hidden = hidden;
  1093.   return n;
  1094. }
  1095.  
  1096. /* Handle linker script assignments and HIDDEN.  */
  1097.  
  1098. etree_type *
  1099. exp_assign (const char *dst, etree_type *src, bfd_boolean hidden)
  1100. {
  1101.   return exp_assop (dst, src, etree_assign, FALSE, hidden);
  1102. }
  1103.  
  1104. /* Handle --defsym command-line option.  */
  1105.  
  1106. etree_type *
  1107. exp_defsym (const char *dst, etree_type *src)
  1108. {
  1109.   return exp_assop (dst, src, etree_assign, TRUE, FALSE);
  1110. }
  1111.  
  1112. /* Handle PROVIDE.  */
  1113.  
  1114. etree_type *
  1115. exp_provide (const char *dst, etree_type *src, bfd_boolean hidden)
  1116. {
  1117.   return exp_assop (dst, src, etree_provide, FALSE, hidden);
  1118. }
  1119.  
  1120. /* Handle ASSERT.  */
  1121.  
  1122. etree_type *
  1123. exp_assert (etree_type *exp, const char *message)
  1124. {
  1125.   etree_type *n;
  1126.  
  1127.   n = (etree_type *) stat_alloc (sizeof (n->assert_s));
  1128.   n->assert_s.type.node_code = '!';
  1129.   n->assert_s.type.filename = exp->type.filename;
  1130.   n->assert_s.type.lineno = exp->type.lineno;
  1131.   n->assert_s.type.node_class = etree_assert;
  1132.   n->assert_s.child = exp;
  1133.   n->assert_s.message = message;
  1134.   return n;
  1135. }
  1136.  
  1137. void
  1138. exp_print_tree (etree_type *tree)
  1139. {
  1140.   bfd_boolean function_like;
  1141.  
  1142.   if (config.map_file == NULL)
  1143.     config.map_file = stderr;
  1144.  
  1145.   if (tree == NULL)
  1146.     {
  1147.       minfo ("NULL TREE\n");
  1148.       return;
  1149.     }
  1150.  
  1151.   switch (tree->type.node_class)
  1152.     {
  1153.     case etree_value:
  1154.       minfo ("0x%v", tree->value.value);
  1155.       return;
  1156.     case etree_rel:
  1157.       if (tree->rel.section->owner != NULL)
  1158.         minfo ("%B:", tree->rel.section->owner);
  1159.       minfo ("%s+0x%v", tree->rel.section->name, tree->rel.value);
  1160.       return;
  1161.     case etree_assign:
  1162.       fputs (tree->assign.dst, config.map_file);
  1163.       exp_print_token (tree->type.node_code, TRUE);
  1164.       exp_print_tree (tree->assign.src);
  1165.       break;
  1166.     case etree_provide:
  1167.     case etree_provided:
  1168.       fprintf (config.map_file, "PROVIDE (%s, ", tree->assign.dst);
  1169.       exp_print_tree (tree->assign.src);
  1170.       fputc (')', config.map_file);
  1171.       break;
  1172.     case etree_binary:
  1173.       function_like = FALSE;
  1174.       switch (tree->type.node_code)
  1175.         {
  1176.         case MAX_K:
  1177.         case MIN_K:
  1178.         case ALIGN_K:
  1179.         case DATA_SEGMENT_ALIGN:
  1180.         case DATA_SEGMENT_RELRO_END:
  1181.           function_like = TRUE;
  1182.           break;
  1183.         case SEGMENT_START:
  1184.           /* Special handling because arguments are in reverse order and
  1185.              the segment name is quoted.  */
  1186.           exp_print_token (tree->type.node_code, FALSE);
  1187.           fputs (" (\"", config.map_file);
  1188.           exp_print_tree (tree->binary.rhs);
  1189.           fputs ("\", ", config.map_file);
  1190.           exp_print_tree (tree->binary.lhs);
  1191.           fputc (')', config.map_file);
  1192.           return;
  1193.         }
  1194.       if (function_like)
  1195.         {
  1196.           exp_print_token (tree->type.node_code, FALSE);
  1197.           fputc (' ', config.map_file);
  1198.         }
  1199.       fputc ('(', config.map_file);
  1200.       exp_print_tree (tree->binary.lhs);
  1201.       if (function_like)
  1202.         fprintf (config.map_file, ", ");
  1203.       else
  1204.         exp_print_token (tree->type.node_code, TRUE);
  1205.       exp_print_tree (tree->binary.rhs);
  1206.       fputc (')', config.map_file);
  1207.       break;
  1208.     case etree_trinary:
  1209.       exp_print_tree (tree->trinary.cond);
  1210.       fputc ('?', config.map_file);
  1211.       exp_print_tree (tree->trinary.lhs);
  1212.       fputc (':', config.map_file);
  1213.       exp_print_tree (tree->trinary.rhs);
  1214.       break;
  1215.     case etree_unary:
  1216.       exp_print_token (tree->unary.type.node_code, FALSE);
  1217.       if (tree->unary.child)
  1218.         {
  1219.           fprintf (config.map_file, " (");
  1220.           exp_print_tree (tree->unary.child);
  1221.           fputc (')', config.map_file);
  1222.         }
  1223.       break;
  1224.  
  1225.     case etree_assert:
  1226.       fprintf (config.map_file, "ASSERT (");
  1227.       exp_print_tree (tree->assert_s.child);
  1228.       fprintf (config.map_file, ", %s)", tree->assert_s.message);
  1229.       break;
  1230.  
  1231.     case etree_name:
  1232.       if (tree->type.node_code == NAME)
  1233.         fputs (tree->name.name, config.map_file);
  1234.       else
  1235.         {
  1236.           exp_print_token (tree->type.node_code, FALSE);
  1237.           if (tree->name.name)
  1238.             fprintf (config.map_file, " (%s)", tree->name.name);
  1239.         }
  1240.       break;
  1241.     default:
  1242.       FAIL ();
  1243.       break;
  1244.     }
  1245. }
  1246.  
  1247. bfd_vma
  1248. exp_get_vma (etree_type *tree, bfd_vma def, char *name)
  1249. {
  1250.   if (tree != NULL)
  1251.     {
  1252.       exp_fold_tree_no_dot (tree);
  1253.       if (expld.result.valid_p)
  1254.         return expld.result.value;
  1255.       else if (name != NULL && expld.phase != lang_mark_phase_enum)
  1256.         einfo (_("%F%S: nonconstant expression for %s\n"),
  1257.                tree, name);
  1258.     }
  1259.   return def;
  1260. }
  1261.  
  1262. int
  1263. exp_get_value_int (etree_type *tree, int def, char *name)
  1264. {
  1265.   return exp_get_vma (tree, def, name);
  1266. }
  1267.  
  1268. fill_type *
  1269. exp_get_fill (etree_type *tree, fill_type *def, char *name)
  1270. {
  1271.   fill_type *fill;
  1272.   size_t len;
  1273.   unsigned int val;
  1274.  
  1275.   if (tree == NULL)
  1276.     return def;
  1277.  
  1278.   exp_fold_tree_no_dot (tree);
  1279.   if (!expld.result.valid_p)
  1280.     {
  1281.       if (name != NULL && expld.phase != lang_mark_phase_enum)
  1282.         einfo (_("%F%S: nonconstant expression for %s\n"),
  1283.                tree, name);
  1284.       return def;
  1285.     }
  1286.  
  1287.   if (expld.result.str != NULL && (len = strlen (expld.result.str)) != 0)
  1288.     {
  1289.       unsigned char *dst;
  1290.       unsigned char *s;
  1291.       fill = (fill_type *) xmalloc ((len + 1) / 2 + sizeof (*fill) - 1);
  1292.       fill->size = (len + 1) / 2;
  1293.       dst = fill->data;
  1294.       s = (unsigned char *) expld.result.str;
  1295.       val = 0;
  1296.       do
  1297.         {
  1298.           unsigned int digit;
  1299.  
  1300.           digit = *s++ - '0';
  1301.           if (digit > 9)
  1302.             digit = (digit - 'A' + '0' + 10) & 0xf;
  1303.           val <<= 4;
  1304.           val += digit;
  1305.           --len;
  1306.           if ((len & 1) == 0)
  1307.             {
  1308.               *dst++ = val;
  1309.               val = 0;
  1310.             }
  1311.         }
  1312.       while (len != 0);
  1313.     }
  1314.   else
  1315.     {
  1316.       fill = (fill_type *) xmalloc (4 + sizeof (*fill) - 1);
  1317.       val = expld.result.value;
  1318.       fill->data[0] = (val >> 24) & 0xff;
  1319.       fill->data[1] = (val >> 16) & 0xff;
  1320.       fill->data[2] = (val >>  8) & 0xff;
  1321.       fill->data[3] = (val >>  0) & 0xff;
  1322.       fill->size = 4;
  1323.     }
  1324.   return fill;
  1325. }
  1326.  
  1327. bfd_vma
  1328. exp_get_abs_int (etree_type *tree, int def, char *name)
  1329. {
  1330.   if (tree != NULL)
  1331.     {
  1332.       exp_fold_tree_no_dot (tree);
  1333.  
  1334.       if (expld.result.valid_p)
  1335.         {
  1336.           if (expld.result.section != NULL)
  1337.             expld.result.value += expld.result.section->vma;
  1338.           return expld.result.value;
  1339.         }
  1340.       else if (name != NULL && expld.phase != lang_mark_phase_enum)
  1341.         {
  1342.           einfo (_("%F%S: nonconstant expression for %s\n"),
  1343.                  tree, name);
  1344.         }
  1345.     }
  1346.   return def;
  1347. }
  1348.  
  1349. static bfd_vma
  1350. align_n (bfd_vma value, bfd_vma align)
  1351. {
  1352.   if (align <= 1)
  1353.     return value;
  1354.  
  1355.   value = (value + align - 1) / align;
  1356.   return value * align;
  1357. }
  1358.