1 files changed, 70 insertions, 75 deletions

diff --git a/bfd/elf64-ppc.c b/bfd/elf64-ppc.c
index b49b6137034..6f30194e6ad 100644
--- a/bfd/elf64-ppc.c
+++ b/bfd/elf64-ppc.c
@@ -3766,7 +3766,6 @@ ppc64_elf_copy_indirect_symbol
    struct elf_link_hash_entry *ind)
 {
   struct ppc_link_hash_entry *edir, *eind;
-  flagword mask;
 
   edir = (struct ppc_link_hash_entry *) dir;
   eind = (struct ppc_link_hash_entry *) ind;
@@ -3810,18 +3809,18 @@ ppc64_elf_copy_indirect_symbol
   edir->is_func_descriptor |= eind->is_func_descriptor;
   edir->tls_mask |= eind->tls_mask;
 
-  mask = (ELF_LINK_HASH_REF_DYNAMIC | ELF_LINK_HASH_REF_REGULAR
-	  | ELF_LINK_HASH_REF_REGULAR_NONWEAK | ELF_LINK_NON_GOT_REF
-	  | ELF_LINK_HASH_NEEDS_PLT);
   /* If called to transfer flags for a weakdef during processing
-     of elf_adjust_dynamic_symbol, don't copy ELF_LINK_NON_GOT_REF.
+     of elf_adjust_dynamic_symbol, don't copy NON_GOT_REF.
      We clear it ourselves for ELIMINATE_COPY_RELOCS.  */
-  if (ELIMINATE_COPY_RELOCS
-      && eind->elf.root.type != bfd_link_hash_indirect
-      && (edir->elf.elf_link_hash_flags & ELF_LINK_HASH_DYNAMIC_ADJUSTED) != 0)
-    mask &= ~ELF_LINK_NON_GOT_REF;
+  if (!(ELIMINATE_COPY_RELOCS
+	&& eind->elf.root.type != bfd_link_hash_indirect
+	&& edir->elf.dynamic_adjusted))
+    edir->elf.non_got_ref |= eind->elf.non_got_ref;
 
-  edir->elf.elf_link_hash_flags |= eind->elf.elf_link_hash_flags & mask;
+  edir->elf.ref_dynamic |= eind->elf.ref_dynamic;
+  edir->elf.ref_regular |= eind->elf.ref_regular;
+  edir->elf.ref_regular_nonweak |= eind->elf.ref_regular_nonweak;
+  edir->elf.needs_plt |= eind->elf.needs_plt;
 
   /* If we were called to copy over info for a weak sym, that's all.  */
   if (eind->elf.root.type != bfd_link_hash_indirect)
@@ -4064,22 +4063,22 @@ ppc64_elf_check_directives (bfd *abfd ATTRIBUTE_UNUSED,
 	  if (h->type != bfd_link_hash_undefined
 	      && h->type != bfd_link_hash_common)
 	    {
-	      *pun = h->und_next;
-	      h->und_next = NULL;
+	      *pun = h->u.undef.next;
+	      h->u.undef.next = NULL;
 	      if (h == htab->elf.root.undefs_tail)
 		{
 		  if (pun == &htab->elf.root.undefs)
 		    htab->elf.root.undefs_tail = NULL;
 		  else
-		    /* pun points at an und_next field.  Go back to
+		    /* pun points at an u.undef.next field.  Go back to
 		       the start of the link_hash_entry.  */
 		    htab->elf.root.undefs_tail = (struct bfd_link_hash_entry *)
-		      ((char *) pun - ((char *) &h->und_next - (char *) h));
+		      ((char *) pun - ((char *) &h->u.undef.next - (char *) h));
 		  break;
 		}
 	    }
 	  else
-	    pun = &h->und_next;
+	    pun = &h->u.undef.next;
 	}
 
       htab->twiddled_syms = 0;
@@ -4155,7 +4154,7 @@ update_plt_info (bfd *abfd, struct ppc_link_hash_entry *eh, bfd_vma addend)
       eh->elf.plt.plist = ent;
     }
   ent->plt.refcount += 1;
-  eh->elf.elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
+  eh->elf.needs_plt = 1;
   eh->is_func = 1;
   return TRUE;
 }
@@ -4551,7 +4550,7 @@ ppc64_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
 	case R_PPC64_TOC:
 	  if (h != NULL && !info->shared)
 	    /* We may need a copy reloc.  */
-	    h->elf_link_hash_flags |= ELF_LINK_NON_GOT_REF;
+	    h->non_got_ref = 1;
 
 	  /* Don't propagate .opd relocs.  */
 	  if (NO_OPD_RELOCS && opd_sym_map != NULL)
@@ -4584,14 +4583,12 @@ ppc64_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
 		   || (h != NULL
 		       && (! info->symbolic
 			   || h->root.type == bfd_link_hash_defweak
-			   || (h->elf_link_hash_flags
-			       & ELF_LINK_HASH_DEF_REGULAR) == 0))))
+			   || !h->def_regular))))
 	      || (ELIMINATE_COPY_RELOCS
 		  && !info->shared
 		  && h != NULL
 		  && (h->root.type == bfd_link_hash_defweak
-		      || (h->elf_link_hash_flags
-			  & ELF_LINK_HASH_DEF_REGULAR) == 0)))
+		      || !h->def_regular)))
 	    {
 	      struct ppc_dyn_relocs *p;
 	      struct ppc_dyn_relocs **head;
@@ -5080,13 +5077,13 @@ sfpr_define (struct bfd_link_info *info, const struct sfpr_def_parms *parm)
       sym[len + 1] = i % 10 + '0';
       h = elf_link_hash_lookup (&htab->elf, sym, FALSE, FALSE, TRUE);
       if (h != NULL
-	  && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
+	  && !h->def_regular)
 	{
 	  h->root.type = bfd_link_hash_defined;
 	  h->root.u.def.section = htab->sfpr;
 	  h->root.u.def.value = htab->sfpr->size;
 	  h->type = STT_FUNC;
-	  h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
+	  h->def_regular = 1;
 	  _bfd_elf_link_hash_hide_symbol (info, h, TRUE);
 	  writing = TRUE;
 	  if (htab->sfpr->contents == NULL)
@@ -5311,7 +5308,7 @@ func_desc_adjust (struct elf_link_hash_entry *h, void *inf)
 			  &fh->elf.root.u.def.value) != (bfd_vma) -1)
     {
       fh->elf.root.type = fh->oh->elf.root.type;
-      fh->elf.elf_link_hash_flags |= ELF_LINK_FORCED_LOCAL;
+      fh->elf.forced_local = 1;
     }
 
   /* If this is a function code symbol, transfer dynamic linking
@@ -5362,27 +5359,26 @@ func_desc_adjust (struct elf_link_hash_entry *h, void *inf)
 	  return FALSE;
 	}
       fdh = (struct ppc_link_hash_entry *) bh;
-      fdh->elf.elf_link_hash_flags &= ~ELF_LINK_NON_ELF;
+      fdh->elf.non_elf = 0;
       fdh->elf.size = 24;
       fdh->elf.type = STT_OBJECT;
     }
 
   if (fdh != NULL
-      && (fdh->elf.elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0
+      && !fdh->elf.forced_local
       && (info->shared
-	  || (fdh->elf.elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
-	  || (fdh->elf.elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) != 0
+	  || fdh->elf.def_dynamic
+	  || fdh->elf.ref_dynamic
 	  || (fdh->elf.root.type == bfd_link_hash_undefweak
 	      && ELF_ST_VISIBILITY (fdh->elf.other) == STV_DEFAULT)))
     {
       if (fdh->elf.dynindx == -1)
 	if (! bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
 	  return FALSE;
-      fdh->elf.elf_link_hash_flags
-	|= (fh->elf.elf_link_hash_flags & (ELF_LINK_HASH_REF_REGULAR
-				      | ELF_LINK_HASH_REF_DYNAMIC
-				      | ELF_LINK_HASH_REF_REGULAR_NONWEAK
-				      | ELF_LINK_NON_GOT_REF));
+      fdh->elf.ref_regular |= fh->elf.ref_regular;
+      fdh->elf.ref_dynamic |= fh->elf.ref_dynamic;
+      fdh->elf.ref_regular_nonweak |= fh->elf.ref_regular_nonweak;
+      fdh->elf.non_got_ref |= fh->elf.non_got_ref;
       if (ELF_ST_VISIBILITY (fh->elf.other) == STV_DEFAULT)
 	{
 	  struct plt_entry **ep = &fdh->elf.plt.plist;
@@ -5390,7 +5386,7 @@ func_desc_adjust (struct elf_link_hash_entry *h, void *inf)
 	    ep = &(*ep)->next;
 	  *ep = fh->elf.plt.plist;
 	  fh->elf.plt.plist = NULL;
-	  fdh->elf.elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
+	  fdh->elf.needs_plt = 1;
 	}
       fdh->is_func_descriptor = 1;
       fdh->oh = fh;
@@ -5406,10 +5402,10 @@ func_desc_adjust (struct elf_link_hash_entry *h, void *inf)
      linker dragging in a definition from a static library.  */
   force_local
     = (info->shared
-       && ((fh->elf.elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0
+       && (!fh->elf.def_regular
 	   || fdh == NULL
-	   || (fdh->elf.elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0
-	   || (fdh->elf.elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0));
+	   || !fdh->elf.def_regular
+	   || fdh->elf.forced_local));
   _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
 
   return TRUE;
@@ -5479,7 +5475,7 @@ ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
 
   /* Deal with function syms.  */
   if (h->type == STT_FUNC
-      || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
+      || h->needs_plt)
     {
       /* Clear procedure linkage table information for any symbol that
 	 won't need a .plt entry.  */
@@ -5493,7 +5489,7 @@ ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
 	      && h->root.type == bfd_link_hash_undefweak))
 	{
 	  h->plt.plist = NULL;
-	  h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
+	  h->needs_plt = 0;
 	}
     }
   else
@@ -5502,16 +5498,14 @@ ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
   /* If this is a weak symbol, and there is a real definition, the
      processor independent code will have arranged for us to see the
      real definition first, and we can just use the same value.  */
-  if (h->weakdef != NULL)
+  if (h->u.weakdef != NULL)
     {
-      BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
-		  || h->weakdef->root.type == bfd_link_hash_defweak);
-      h->root.u.def.section = h->weakdef->root.u.def.section;
-      h->root.u.def.value = h->weakdef->root.u.def.value;
+      BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
+		  || h->u.weakdef->root.type == bfd_link_hash_defweak);
+      h->root.u.def.section = h->u.weakdef->root.u.def.section;
+      h->root.u.def.value = h->u.weakdef->root.u.def.value;
       if (ELIMINATE_COPY_RELOCS)
-	h->elf_link_hash_flags
-	  = ((h->elf_link_hash_flags & ~ELF_LINK_NON_GOT_REF)
-	     | (h->weakdef->elf_link_hash_flags & ELF_LINK_NON_GOT_REF));
+	h->non_got_ref = h->u.weakdef->non_got_ref;
       return TRUE;
     }
 
@@ -5524,7 +5518,7 @@ ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
 
   /* If there are no references to this symbol that do not use the
      GOT, we don't need to generate a copy reloc.  */
-  if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0)
+  if (!h->non_got_ref)
     return TRUE;
 
   if (ELIMINATE_COPY_RELOCS)
@@ -5544,7 +5538,7 @@ ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
 	 we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
       if (p == NULL)
 	{
-	  h->elf_link_hash_flags &= ~ELF_LINK_NON_GOT_REF;
+	  h->non_got_ref = 0;
 	  return TRUE;
 	}
     }
@@ -5582,7 +5576,7 @@ ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
     {
       htab->relbss->size += sizeof (Elf64_External_Rela);
-      h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY;
+      h->needs_copy = 1;
     }
 
   /* We need to figure out the alignment required for this symbol.  I
@@ -5812,7 +5806,7 @@ get_tls_mask (char **tls_maskp, unsigned long *toc_symndx,
   if ((h == NULL
        || ((h->root.type == bfd_link_hash_defined
 	    || h->root.type == bfd_link_hash_defweak)
-	   && !(h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC)))
+	   && !h->def_dynamic))
       && (next_r == -1 || next_r == -2))
     return 1 - next_r;
   return 1;
@@ -6404,7 +6398,7 @@ ppc64_elf_tls_optimize (bfd *obfd ATTRIBUTE_UNUSED, struct bfd_link_info *info)
 		ok_tprel = FALSE;
 		is_local = FALSE;
 		if (h == NULL
-		    || !(h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC))
+		    || !h->def_dynamic)
 		  {
 		    is_local = TRUE;
 		    value += sym_sec->output_offset;
@@ -6683,13 +6677,13 @@ allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
       if (!doneone)
 	{
 	  h->plt.plist = NULL;
-	  h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
+	  h->needs_plt = 0;
 	}
     }
   else
     {
       h->plt.plist = NULL;
-      h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
+      h->needs_plt = 0;
     }
 
   eh = (struct ppc_link_hash_entry *) h;
@@ -6727,14 +6721,14 @@ allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
 	   Undefined weak syms won't yet be marked as dynamic,
 	   nor will all TLS symbols.  */
 	if (h->dynindx == -1
-	    && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
+	    && !h->forced_local)
 	  {
 	    if (! bfd_elf_link_record_dynamic_symbol (info, h))
 	      return FALSE;
 	  }
 
 	if ((gent->tls_type & TLS_LD) != 0
-	    && !(h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC))
+	    && !h->def_dynamic)
 	  {
 	    gent->got.offset = ppc64_tlsld_got (gent->owner)->offset;
 	    continue;
@@ -6801,14 +6795,14 @@ allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
 	 symbols which turn out to need copy relocs or are not
 	 dynamic.  */
 
-      if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0
-	  && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
-	  && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
+      if (!h->non_got_ref
+	  && h->def_dynamic
+	  && !h->def_regular)
 	{
 	  /* Make sure this symbol is output as a dynamic symbol.
 	     Undefined weak syms won't yet be marked as dynamic.  */
 	  if (h->dynindx == -1
-	      && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
+	      && !h->forced_local)
 	    {
 	      if (! bfd_elf_link_record_dynamic_symbol (info, h))
 		return FALSE;
@@ -7537,10 +7531,11 @@ ppc_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
 	  h->root.type = bfd_link_hash_defined;
 	  h->root.u.def.section = stub_entry->stub_sec;
 	  h->root.u.def.value = stub_entry->stub_offset;
-	  h->elf_link_hash_flags = (ELF_LINK_HASH_REF_REGULAR
-				    | ELF_LINK_HASH_DEF_REGULAR
-				    | ELF_LINK_HASH_REF_REGULAR_NONWEAK
-				    | ELF_LINK_FORCED_LOCAL);
+	  h->ref_regular = 1;
+	  h->def_regular = 1;
+	  h->ref_regular_nonweak = 1;
+	  h->forced_local = 1;
+	  h->non_elf = 0;
 	}
     }
 
@@ -8403,10 +8398,11 @@ ppc64_elf_build_stubs (bfd_boolean emit_stub_syms,
 	      h->root.type = bfd_link_hash_defined;
 	      h->root.u.def.section = htab->glink;
 	      h->root.u.def.value = 0;
-	      h->elf_link_hash_flags = (ELF_LINK_HASH_REF_REGULAR
-					| ELF_LINK_HASH_DEF_REGULAR
-					| ELF_LINK_HASH_REF_REGULAR_NONWEAK
-					| ELF_LINK_FORCED_LOCAL);
+	      h->ref_regular = 1;
+	      h->def_regular = 1;
+	      h->ref_regular_nonweak = 1;
+	      h->forced_local = 1;
+	      h->non_elf = 0;
 	    }
 	}
       p = htab->glink->contents;
@@ -9322,8 +9318,7 @@ ppc64_elf_relocate_section (bfd *output_bfd,
 
 	    if (tls_type == (TLS_TLS | TLS_LD)
 		&& (h == NULL
-		    || (h->elf.elf_link_hash_flags
-			& ELF_LINK_HASH_DEF_DYNAMIC) == 0))
+		    || !h->elf.def_dynamic))
 	      offp = &ppc64_tlsld_got (input_bfd)->offset;
 	    else
 	      {
@@ -9642,9 +9637,9 @@ ppc64_elf_relocate_section (bfd *output_bfd,
 		  && !info->shared
 		  && h != NULL
 		  && h->elf.dynindx != -1
-		  && !(h->elf.elf_link_hash_flags & ELF_LINK_NON_GOT_REF)
-		  && (h->elf.elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC)
-		  && !(h->elf.elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
+		  && !h->elf.non_got_ref
+		  && h->elf.def_dynamic
+		  && !h->elf.def_regular))
 	    {
 	      Elf_Internal_Rela outrel;
 	      bfd_boolean skip, relocate;
@@ -9897,7 +9892,7 @@ ppc64_elf_relocate_section (bfd *output_bfd,
 	 not process them.  */
       if (unresolved_reloc
 	  && !((input_section->flags & SEC_DEBUGGING) != 0
-	       && (h->elf.elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC)))
+	       && h->elf.def_dynamic))
 	{
 	  (*_bfd_error_handler)
 	    (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
@@ -10035,7 +10030,7 @@ ppc64_elf_finish_dynamic_symbol (bfd *output_bfd,
 	bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
       }
 
-  if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
+  if (h->needs_copy)
     {
       Elf_Internal_Rela rela;
       bfd_byte *loc;