PR ld/11583

[deliverable/binutils-gdb.git] / ld / ldexp.c

diff --git a/ld/ldexp.c b/ld/ldexp.c
index e888c95349c1d85560f6ef0b9890ce46e3424edb..34d9eabde7f67506d79f54afdcdc262b194d7b30 100644 (file)
--- a/ld/ldexp.c
+++ b/ld/ldexp.c
@@ -1,6 +1,6 @@
 /* This module handles expression trees.
    Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
-   2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008
+   2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
    Free Software Foundation, Inc.
    Written by Steve Chamberlain of Cygnus Support <sac@cygnus.com>.
 
@@ -154,25 +154,25 @@ new_abs (bfd_vma value)
 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 *new_e = (etree_type *) stat_alloc (sizeof (new_e->value));
+  new_e->type.node_code = INT;
+  new_e->type.lineno = lineno;
+  new_e->value.value = value;
+  new_e->value.str = NULL;
+  new_e->type.node_class = etree_value;
+  return new_e;
 }
 
 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;
+  etree_type *new_e = (etree_type *) stat_alloc (sizeof (new_e->value));
+  new_e->type.node_code = INT;
+  new_e->type.lineno = lineno;
+  new_e->value.value = value;
+  new_e->value.str = str;
+  new_e->type.node_class = etree_value;
+  return new_e;
 }
 
 /* Build an expression representing an unnamed relocatable value.  */
@@ -180,13 +180,13 @@ exp_bigintop (bfd_vma value, char *str)
 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;
+  etree_type *new_e = (etree_type *) stat_alloc (sizeof (new_e->rel));
+  new_e->type.node_code = REL;
+  new_e->type.lineno = lineno;
+  new_e->type.node_class = etree_rel;
+  new_e->rel.section = section;
+  new_e->rel.value = value;
+  return new_e;
 }
 
 static void
@@ -673,9 +673,9 @@ fold_name (etree_type *tree)
 
     case CONSTANT:
       if (strcmp (tree->name.name, "MAXPAGESIZE") == 0)
-       new_abs (bfd_emul_get_maxpagesize (default_target));
+       new_abs (config.maxpagesize);
       else if (strcmp (tree->name.name, "COMMONPAGESIZE") == 0)
-       new_abs (bfd_emul_get_commonpagesize (default_target));
+       new_abs (config.commonpagesize);
       else
        einfo (_("%F%S: unknown constant `%s' referenced in expression\n"),
               tree->name.name);
@@ -815,6 +815,28 @@ exp_fold_tree_1 (etree_type *tree)
              h->u.def.section = expld.result.section;
              if (tree->type.node_class == etree_provide)
                tree->type.node_class = etree_provided;
+
+             /* Copy the symbol type if this is a simple assignment of
+                one symbol to annother.  */
+             if (tree->assign.src->type.node_class == etree_name)
+               {
+                 struct bfd_link_hash_entry *hsrc;
+
+                 hsrc = bfd_link_hash_lookup (link_info.hash,
+                                              tree->assign.src->name.name,
+                                              FALSE, FALSE, TRUE);
+                 if (hsrc)
+                   bfd_copy_link_hash_symbol_type (link_info.output_bfd, h,
+                                                   hsrc);
+               }
+           }
+         else if (expld.phase == lang_final_phase_enum)
+           {
+             h = bfd_link_hash_lookup (link_info.hash, tree->assign.dst,
+                                       FALSE, FALSE, TRUE);
+             if (h != NULL
+                 && h->type == bfd_link_hash_new)
+               h->type = bfd_link_hash_undefined;
            }
        }
       break;
@@ -851,7 +873,7 @@ exp_fold_tree_no_dot (etree_type *tree)
 etree_type *
 exp_binop (int code, etree_type *lhs, etree_type *rhs)
 {
-  etree_type value, *new;
+  etree_type value, *new_e;
 
   value.type.node_code = code;
   value.type.lineno = lhs->type.lineno;
@@ -862,15 +884,15 @@ exp_binop (int code, etree_type *lhs, etree_type *rhs)
   if (expld.result.valid_p)
     return exp_intop (expld.result.value);
 
-  new = stat_alloc (sizeof (new->binary));
-  memcpy (new, &value, sizeof (new->binary));
-  return new;
+  new_e = (etree_type *) stat_alloc (sizeof (new_e->binary));
+  memcpy (new_e, &value, sizeof (new_e->binary));
+  return new_e;
 }
 
 etree_type *
 exp_trinop (int code, etree_type *cond, etree_type *lhs, etree_type *rhs)
 {
-  etree_type value, *new;
+  etree_type value, *new_e;
 
   value.type.node_code = code;
   value.type.lineno = lhs->type.lineno;
@@ -882,15 +904,15 @@ exp_trinop (int code, etree_type *cond, etree_type *lhs, etree_type *rhs)
   if (expld.result.valid_p)
     return exp_intop (expld.result.value);
 
-  new = stat_alloc (sizeof (new->trinary));
-  memcpy (new, &value, sizeof (new->trinary));
-  return new;
+  new_e = (etree_type *) stat_alloc (sizeof (new_e->trinary));
+  memcpy (new_e, &value, sizeof (new_e->trinary));
+  return new_e;
 }
 
 etree_type *
 exp_unop (int code, etree_type *child)
 {
-  etree_type value, *new;
+  etree_type value, *new_e;
 
   value.unary.type.node_code = code;
   value.unary.type.lineno = child->type.lineno;
@@ -900,15 +922,15 @@ exp_unop (int code, etree_type *child)
   if (expld.result.valid_p)
     return exp_intop (expld.result.value);
 
-  new = stat_alloc (sizeof (new->unary));
-  memcpy (new, &value, sizeof (new->unary));
-  return new;
+  new_e = (etree_type *) stat_alloc (sizeof (new_e->unary));
+  memcpy (new_e, &value, sizeof (new_e->unary));
+  return new_e;
 }
 
 etree_type *
 exp_nameop (int code, const char *name)
 {
-  etree_type value, *new;
+  etree_type value, *new_e;
 
   value.name.type.node_code = code;
   value.name.type.lineno = lineno;
@@ -919,24 +941,24 @@ exp_nameop (int code, const char *name)
   if (expld.result.valid_p)
     return exp_intop (expld.result.value);
 
-  new = stat_alloc (sizeof (new->name));
-  memcpy (new, &value, sizeof (new->name));
-  return new;
+  new_e = (etree_type *) stat_alloc (sizeof (new_e->name));
+  memcpy (new_e, &value, sizeof (new_e->name));
+  return new_e;
 
 }
 
 etree_type *
 exp_assop (int code, const char *dst, etree_type *src)
 {
-  etree_type *new;
-
-  new = stat_alloc (sizeof (new->assign));
-  new->type.node_code = code;
-  new->type.lineno = src->type.lineno;
-  new->type.node_class = etree_assign;
-  new->assign.src = src;
-  new->assign.dst = dst;
-  return new;
+  etree_type *new_e;
+
+  new_e = (etree_type *) stat_alloc (sizeof (new_e->assign));
+  new_e->type.node_code = code;
+  new_e->type.lineno = src->type.lineno;
+  new_e->type.node_class = etree_assign;
+  new_e->assign.src = src;
+  new_e->assign.dst = dst;
+  return new_e;
 }
 
 /* Handle PROVIDE.  */
@@ -946,7 +968,7 @@ exp_provide (const char *dst, etree_type *src, bfd_boolean hidden)
 {
   etree_type *n;
 
-  n = stat_alloc (sizeof (n->assign));
+  n = (etree_type *) stat_alloc (sizeof (n->assign));
   n->assign.type.node_code = '=';
   n->assign.type.lineno = src->type.lineno;
   n->assign.type.node_class = etree_provide;
@@ -963,7 +985,7 @@ exp_assert (etree_type *exp, const char *message)
 {
   etree_type *n;
 
-  n = stat_alloc (sizeof (n->assert_s));
+  n = (etree_type *) stat_alloc (sizeof (n->assert_s));
   n->assert_s.type.node_code = '!';
   n->assert_s.type.lineno = exp->type.lineno;
   n->assert_s.type.node_class = etree_assert;
@@ -1095,7 +1117,7 @@ exp_get_fill (etree_type *tree, fill_type *def, char *name)
     {
       unsigned char *dst;
       unsigned char *s;
-      fill = xmalloc ((len + 1) / 2 + sizeof (*fill) - 1);
+      fill = (fill_type *) xmalloc ((len + 1) / 2 + sizeof (*fill) - 1);
       fill->size = (len + 1) / 2;
       dst = fill->data;
       s = (unsigned char *) expld.result.str;
@@ -1120,7 +1142,7 @@ exp_get_fill (etree_type *tree, fill_type *def, char *name)
     }
   else
     {
-      fill = xmalloc (4 + sizeof (*fill) - 1);
+      fill = (fill_type *) xmalloc (4 + sizeof (*fill) - 1);
       val = expld.result.value;
       fill->data[0] = (val >> 24) & 0xff;
       fill->data[1] = (val >> 16) & 0xff;