Subversion Repositories openrisc

/* This module handles expression trees.

   Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,

   2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008

   Free Software Foundation, Inc.

   Written by Steve Chamberlain of Cygnus Support <sac@cygnus.com>.

   This file is part of the GNU Binutils.

   This program is free software; you can redistribute it and/or modify

   it under the terms of the GNU General Public License as published by

   the Free Software Foundation; either version 3 of the License, or

   (at your option) any later version.

   This program is distributed in the hope that it will be useful,

   but WITHOUT ANY WARRANTY; without even the implied warranty of

   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License

   along with this program; if not, write to the Free Software

   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,

   MA 02110-1301, USA.  */

/* This module is in charge of working out the contents of expressions.

   It has to keep track of the relative/absness of a symbol etc. This

   is done by keeping all values in a struct (an etree_value_type)

   which contains a value, a section to which it is relative and a

   valid bit.  */

#include "sysdep.h"

#include "bfd.h"

#include "bfdlink.h"

#include "ld.h"

#include "ldmain.h"

#include "ldmisc.h"

#include "ldexp.h"

#include "ldlex.h"

#include <ldgram.h>

#include "ldlang.h"

#include "libiberty.h"

#include "safe-ctype.h"

static void exp_fold_tree_1 (etree_type *);

static void exp_fold_tree_no_dot (etree_type *);

static bfd_vma align_n (bfd_vma, bfd_vma);

segment_type *segments;

struct ldexp_control expld;

/* Print the string representation of the given token.  Surround it

   with spaces if INFIX_P is TRUE.  */

static void

exp_print_token (token_code_type code, int infix_p)

{

  static const struct

  {

    token_code_type code;

    char * name;

  }

  table[] =

  {

    { INT, "int" },

    { NAME, "NAME" },

    { PLUSEQ, "+=" },

    { MINUSEQ, "-=" },

    { MULTEQ, "*=" },

    { DIVEQ, "/=" },

    { LSHIFTEQ, "<<=" },

    { RSHIFTEQ, ">>=" },

    { ANDEQ, "&=" },

    { OREQ, "|=" },

    { OROR, "||" },

    { ANDAND, "&&" },

    { EQ, "==" },

    { NE, "!=" },

    { LE, "<=" },

    { GE, ">=" },

    { LSHIFT, "<<" },

    { RSHIFT, ">>" },

    { ALIGN_K, "ALIGN" },

    { BLOCK, "BLOCK" },

    { QUAD, "QUAD" },

    { SQUAD, "SQUAD" },

    { LONG, "LONG" },

    { SHORT, "SHORT" },

    { BYTE, "BYTE" },

    { SECTIONS, "SECTIONS" },

    { SIZEOF_HEADERS, "SIZEOF_HEADERS" },

    { MEMORY, "MEMORY" },

    { DEFINED, "DEFINED" },

    { TARGET_K, "TARGET" },

    { SEARCH_DIR, "SEARCH_DIR" },

    { MAP, "MAP" },

    { ENTRY, "ENTRY" },

    { NEXT, "NEXT" },

    { ALIGNOF, "ALIGNOF" },

    { SIZEOF, "SIZEOF" },

    { ADDR, "ADDR" },

    { LOADADDR, "LOADADDR" },

    { CONSTANT, "CONSTANT" },

    { MAX_K, "MAX_K" },

    { REL, "relocatable" },

    { DATA_SEGMENT_ALIGN, "DATA_SEGMENT_ALIGN" },

    { DATA_SEGMENT_RELRO_END, "DATA_SEGMENT_RELRO_END" },

    { DATA_SEGMENT_END, "DATA_SEGMENT_END" },

    { ORIGIN, "ORIGIN" },

    { LENGTH, "LENGTH" },

    { SEGMENT_START, "SEGMENT_START" }

  };

  unsigned int idx;

  for (idx = 0; idx < ARRAY_SIZE (table); idx++)

    if (table[idx].code == code)

      break;

  if (infix_p)

    fputc (' ', config.map_file);

  if (idx < ARRAY_SIZE (table))

    fputs (table[idx].name, config.map_file);

  else if (code < 127)

    fputc (code, config.map_file);

  else

    fprintf (config.map_file, "<code %d>", code);

  if (infix_p)

    fputc (' ', config.map_file);

}

static void

make_abs (void)

{

  expld.result.value += expld.result.section->vma;

  expld.result.section = bfd_abs_section_ptr;

}

static void

new_abs (bfd_vma value)

{

  expld.result.valid_p = TRUE;

  expld.result.section = bfd_abs_section_ptr;

  expld.result.value = value;

  expld.result.str = NULL;

}

etree_type *

exp_intop (bfd_vma value)

{

  etree_type *new = stat_alloc (sizeof (new->value));

  new->type.node_code = INT;

  new->type.lineno = lineno;

  new->value.value = value;

  new->value.str = NULL;

  new->type.node_class = etree_value;

  return new;

}

etree_type *

exp_bigintop (bfd_vma value, char *str)

{

  etree_type *new = stat_alloc (sizeof (new->value));

  new->type.node_code = INT;

  new->type.lineno = lineno;

  new->value.value = value;

  new->value.str = str;

  new->type.node_class = etree_value;

  return new;

}

/* Build an expression representing an unnamed relocatable value.  */

etree_type *

exp_relop (asection *section, bfd_vma value)

{

  etree_type *new = stat_alloc (sizeof (new->rel));

  new->type.node_code = REL;

  new->type.lineno = lineno;

  new->type.node_class = etree_rel;

  new->rel.section = section;

  new->rel.value = value;

  return new;

}

static void

new_rel (bfd_vma value, char *str, asection *section)

{

  expld.result.valid_p = TRUE;

  expld.result.value = value;

  expld.result.str = str;

  expld.result.section = section;

}

static void

new_rel_from_abs (bfd_vma value)

{

  expld.result.valid_p = TRUE;

  expld.result.value = value - expld.section->vma;

  expld.result.str = NULL;

  expld.result.section = expld.section;

}

static void

fold_unary (etree_type *tree)

{

  exp_fold_tree_1 (tree->unary.child);

  if (expld.result.valid_p)

    {

      switch (tree->type.node_code)

        {

        case ALIGN_K:

          if (expld.phase != lang_first_phase_enum)

            new_rel_from_abs (align_n (expld.dot, expld.result.value));

          else

            expld.result.valid_p = FALSE;

          break;

        case ABSOLUTE:

          make_abs ();

          break;

        case '~':

          make_abs ();

          expld.result.value = ~expld.result.value;

          break;

        case '!':

          make_abs ();

          expld.result.value = !expld.result.value;

          break;

        case '-':

          make_abs ();

          expld.result.value = -expld.result.value;

          break;

        case NEXT:

          /* Return next place aligned to value.  */

          if (expld.phase != lang_first_phase_enum)

            {

              make_abs ();

              expld.result.value = align_n (expld.dot, expld.result.value);

            }

          else

            expld.result.valid_p = FALSE;

          break;

        case DATA_SEGMENT_END:

          if (expld.phase != lang_first_phase_enum

              && expld.section == bfd_abs_section_ptr

              && (expld.dataseg.phase == exp_dataseg_align_seen

                  || expld.dataseg.phase == exp_dataseg_relro_seen

                  || expld.dataseg.phase == exp_dataseg_adjust

                  || expld.dataseg.phase == exp_dataseg_relro_adjust

                  || expld.phase == lang_final_phase_enum))

            {

              if (expld.dataseg.phase == exp_dataseg_align_seen

                  || expld.dataseg.phase == exp_dataseg_relro_seen)

                {

                  expld.dataseg.phase = exp_dataseg_end_seen;

                  expld.dataseg.end = expld.result.value;

                }

            }

          else

            expld.result.valid_p = FALSE;

          break;

        default:

          FAIL ();

          break;

        }

    }

}

static void

fold_binary (etree_type *tree)

{

  exp_fold_tree_1 (tree->binary.lhs);

  /* The SEGMENT_START operator is special because its first

     operand is a string, not the name of a symbol.  */

  if (expld.result.valid_p && tree->type.node_code == SEGMENT_START)

    {

      const char *segment_name;

      segment_type *seg;

      /* Check to see if the user has overridden the default

         value.  */

      segment_name = tree->binary.rhs->name.name;

      for (seg = segments; seg; seg = seg->next)

        if (strcmp (seg->name, segment_name) == 0)

          {

            seg->used = TRUE;

            expld.result.value = seg->value;

            expld.result.str = NULL;

            expld.result.section = NULL;

            break;

          }

    }

  else if (expld.result.valid_p)

    {

      etree_value_type lhs = expld.result;

      exp_fold_tree_1 (tree->binary.rhs);

      if (expld.result.valid_p)

        {

          /* If the values are from different sections, or this is an

             absolute expression, make both the source arguments

             absolute.  However, adding or subtracting an absolute

             value from a relative value is meaningful, and is an

             exception.  */

          if (expld.section != bfd_abs_section_ptr

              && lhs.section == bfd_abs_section_ptr

              && tree->type.node_code == '+')

            {

              /* Keep the section of the rhs term.  */

              expld.result.value = lhs.value + expld.result.value;

              return;

            }

          else if (expld.section != bfd_abs_section_ptr

              && expld.result.section == bfd_abs_section_ptr

              && (tree->type.node_code == '+'

                  || tree->type.node_code == '-'))

            {

              /* Keep the section of the lhs term.  */

              expld.result.section = lhs.section;

            }

          else if (expld.result.section != lhs.section

                   || expld.section == bfd_abs_section_ptr)

            {

              make_abs ();

              lhs.value += lhs.section->vma;

            }

          switch (tree->type.node_code)

            {

            case '%':

              if (expld.result.value != 0)

                expld.result.value = ((bfd_signed_vma) lhs.value

                                      % (bfd_signed_vma) expld.result.value);

              else if (expld.phase != lang_mark_phase_enum)

                einfo (_("%F%S %% by zero\n"));

              break;

            case '/':

              if (expld.result.value != 0)

                expld.result.value = ((bfd_signed_vma) lhs.value

                                      / (bfd_signed_vma) expld.result.value);

              else if (expld.phase != lang_mark_phase_enum)

                einfo (_("%F%S / by zero\n"));

              break;

#define BOP(x, y) \

            case x:                                                     \

              expld.result.value = lhs.value y expld.result.value;      \

              break;

              BOP ('+', +);

              BOP ('*', *);

              BOP ('-', -);

              BOP (LSHIFT, <<);

              BOP (RSHIFT, >>);

              BOP (EQ, ==);

              BOP (NE, !=);

              BOP ('<', <);

              BOP ('>', >);

              BOP (LE, <=);

              BOP (GE, >=);

              BOP ('&', &);

              BOP ('^', ^);

              BOP ('|', |);

              BOP (ANDAND, &&);

              BOP (OROR, ||);

            case MAX_K:

              if (lhs.value > expld.result.value)

                expld.result.value = lhs.value;

              break;

            case MIN_K:

              if (lhs.value < expld.result.value)

                expld.result.value = lhs.value;

              break;

            case ALIGN_K:

              expld.result.value = align_n (lhs.value, expld.result.value);

              break;

            case DATA_SEGMENT_ALIGN:

              expld.dataseg.relro = exp_dataseg_relro_start;

              if (expld.phase != lang_first_phase_enum

                  && expld.section == bfd_abs_section_ptr

                  && (expld.dataseg.phase == exp_dataseg_none

                      || expld.dataseg.phase == exp_dataseg_adjust

                      || expld.dataseg.phase == exp_dataseg_relro_adjust

                      || expld.phase == lang_final_phase_enum))

                {

                  bfd_vma maxpage = lhs.value;

                  bfd_vma commonpage = expld.result.value;

                  expld.result.value = align_n (expld.dot, maxpage);

                  if (expld.dataseg.phase == exp_dataseg_relro_adjust)

                    expld.result.value = expld.dataseg.base;

                  else if (expld.dataseg.phase != exp_dataseg_adjust)

                    {

                      expld.result.value += expld.dot & (maxpage - 1);

                      if (expld.phase == lang_allocating_phase_enum)

                        {

                          expld.dataseg.phase = exp_dataseg_align_seen;

                          expld.dataseg.min_base = align_n (expld.dot, maxpage);

                          expld.dataseg.base = expld.result.value;

                          expld.dataseg.pagesize = commonpage;

                          expld.dataseg.maxpagesize = maxpage;

                          expld.dataseg.relro_end = 0;

                        }

                    }

                  else if (commonpage < maxpage)

                    expld.result.value += ((expld.dot + commonpage - 1)

                                           & (maxpage - commonpage));

                }

              else

                expld.result.valid_p = FALSE;

              break;

            case DATA_SEGMENT_RELRO_END:

              expld.dataseg.relro = exp_dataseg_relro_end;

              if (expld.phase != lang_first_phase_enum

                  && (expld.dataseg.phase == exp_dataseg_align_seen

                      || expld.dataseg.phase == exp_dataseg_adjust

                      || expld.dataseg.phase == exp_dataseg_relro_adjust

                      || expld.phase == lang_final_phase_enum))

                {

                  if (expld.dataseg.phase == exp_dataseg_align_seen

                      || expld.dataseg.phase == exp_dataseg_relro_adjust)

                    expld.dataseg.relro_end = lhs.value + expld.result.value;

                  if (expld.dataseg.phase == exp_dataseg_relro_adjust

                      && (expld.dataseg.relro_end

                          & (expld.dataseg.pagesize - 1)))

                    {

                      expld.dataseg.relro_end += expld.dataseg.pagesize - 1;

                      expld.dataseg.relro_end &= ~(expld.dataseg.pagesize - 1);

                      expld.result.value = (expld.dataseg.relro_end

                                            - expld.result.value);

                    }

                  else

                    expld.result.value = lhs.value;

                  if (expld.dataseg.phase == exp_dataseg_align_seen)

                    expld.dataseg.phase = exp_dataseg_relro_seen;

                }

              else

                expld.result.valid_p = FALSE;

              break;

            default:

              FAIL ();

            }

        }

      else

        expld.result.valid_p = FALSE;

    }

}

static void

fold_trinary (etree_type *tree)

{

  exp_fold_tree_1 (tree->trinary.cond);

  if (expld.result.valid_p)

    exp_fold_tree_1 (expld.result.value

                     ? tree->trinary.lhs

                     : tree->trinary.rhs);

}

static void

fold_name (etree_type *tree)

{

  memset (&expld.result, 0, sizeof (expld.result));

  switch (tree->type.node_code)

    {

    case SIZEOF_HEADERS:

      if (expld.phase != lang_first_phase_enum)

        {

          bfd_vma hdr_size = 0;

          /* Don't find the real header size if only marking sections;

             The bfd function may cache incorrect data.  */

          if (expld.phase != lang_mark_phase_enum)

            hdr_size = bfd_sizeof_headers (link_info.output_bfd, &link_info);

          new_abs (hdr_size);

        }

      break;

    case DEFINED:

      if (expld.phase == lang_first_phase_enum)

        lang_track_definedness (tree->name.name);

      else

        {

          struct bfd_link_hash_entry *h;

          int def_iteration

            = lang_symbol_definition_iteration (tree->name.name);

          h = bfd_wrapped_link_hash_lookup (link_info.output_bfd,

                                            &link_info,

                                            tree->name.name,

                                            FALSE, FALSE, TRUE);

          expld.result.value = (h != NULL

                                && (h->type == bfd_link_hash_defined

                                    || h->type == bfd_link_hash_defweak

                                    || h->type == bfd_link_hash_common)

                                && (def_iteration == lang_statement_iteration

                                    || def_iteration == -1));

          expld.result.section = bfd_abs_section_ptr;

          expld.result.valid_p = TRUE;

        }

      break;

    case NAME:

      if (expld.phase == lang_first_phase_enum)

        ;

      else if (tree->name.name[0] == '.' && tree->name.name[1] == 0)

        new_rel_from_abs (expld.dot);

      else

        {

          struct bfd_link_hash_entry *h;

          h = bfd_wrapped_link_hash_lookup (link_info.output_bfd,

                                            &link_info,

                                            tree->name.name,

                                            TRUE, FALSE, TRUE);

          if (!h)

            einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));

          else if (h->type == bfd_link_hash_defined

                   || h->type == bfd_link_hash_defweak)

            {

              if (bfd_is_abs_section (h->u.def.section))

                new_abs (h->u.def.value);

              else

                {

                  asection *output_section;

                  output_section = h->u.def.section->output_section;

                  if (output_section == NULL)

                    {

                      if (expld.phase != lang_mark_phase_enum)

                        einfo (_("%X%S: unresolvable symbol `%s'"

                                 " referenced in expression\n"),

                               tree->name.name);

                    }

                  else

                    new_rel (h->u.def.value + h->u.def.section->output_offset,

                             NULL, output_section);

                }

            }

          else if (expld.phase == lang_final_phase_enum

                   || expld.assigning_to_dot)

            einfo (_("%F%S: undefined symbol `%s' referenced in expression\n"),

                   tree->name.name);

          else if (h->type == bfd_link_hash_new)

            {

              h->type = bfd_link_hash_undefined;

              h->u.undef.abfd = NULL;

              if (h->u.undef.next == NULL && h != link_info.hash->undefs_tail)

                bfd_link_add_undef (link_info.hash, h);

            }

        }

      break;

    case ADDR:

      if (expld.phase != lang_first_phase_enum)

        {

          lang_output_section_statement_type *os;

          os = lang_output_section_find (tree->name.name);

          if (os == NULL)

            {

              if (expld.phase == lang_final_phase_enum)

                einfo (_("%F%S: undefined section `%s' referenced in expression\n"),

                       tree->name.name);

            }

          else if (os->processed_vma)

            new_rel (0, NULL, os->bfd_section);

        }

      break;

    case LOADADDR:

      if (expld.phase != lang_first_phase_enum)

        {

          lang_output_section_statement_type *os;

          os = lang_output_section_find (tree->name.name);

          if (os == NULL)

            {

              if (expld.phase == lang_final_phase_enum)

                einfo (_("%F%S: undefined section `%s' referenced in expression\n"),

                       tree->name.name);

            }

          else if (os->processed_lma)

            {

              if (os->load_base == NULL)

                new_abs (os->bfd_section->lma);

              else

                {

                  exp_fold_tree_1 (os->load_base);

                  if (expld.result.valid_p)

                    make_abs ();

                }

            }

        }

      break;

    case SIZEOF:

    case ALIGNOF:

      if (expld.phase != lang_first_phase_enum)

        {

          lang_output_section_statement_type *os;

          os = lang_output_section_find (tree->name.name);

          if (os == NULL)

            {

              if (expld.phase == lang_final_phase_enum)

                einfo (_("%F%S: undefined section `%s' referenced in expression\n"),

                       tree->name.name);

              new_abs (0);

            }

          else if (os->processed_vma)

            {

              bfd_vma val;

              if (tree->type.node_code == SIZEOF)

                val = (os->bfd_section->size

                       / bfd_octets_per_byte (link_info.output_bfd));

              else

                val = (bfd_vma)1 << os->bfd_section->alignment_power;

              new_abs (val);

            }

        }

      break;

    case LENGTH:

      {

        lang_memory_region_type *mem;