gdb: make symfile_segment_data::segment_info an std::vector

[deliverable/binutils-gdb.git] / bfd / elfnn-aarch64.c

diff --git a/bfd/elfnn-aarch64.c b/bfd/elfnn-aarch64.c
index 51d7526a720bdb30d81db254d7348fb04ecff63f..02df893fcdd41d0ddaf31eb5b8c613615790da38 100644 (file)
--- a/bfd/elfnn-aarch64.c
+++ b/bfd/elfnn-aarch64.c
@@ -1,5 +1,5 @@
 /* AArch64-specific support for NN-bit ELF.
 /* AArch64-specific support for NN-bit ELF.

-   Copyright (C) 2009-2019 Free Software Foundation, Inc.
+   Copyright (C) 2009-2020 Free Software Foundation, Inc.

    Contributed by ARM Ltd.
 
    This file is part of BFD, the Binary File Descriptor library.
    Contributed by ARM Ltd.
 
    This file is part of BFD, the Binary File Descriptor library.


@@ -2947,7 +2947,7 @@ static struct bfd_link_hash_table *
 elfNN_aarch64_link_hash_table_create (bfd *abfd)
 {
   struct elf_aarch64_link_hash_table *ret;
 elfNN_aarch64_link_hash_table_create (bfd *abfd)
 {
   struct elf_aarch64_link_hash_table *ret;

-  bfd_size_type amt = sizeof (struct elf_aarch64_link_hash_table);
+  size_t amt = sizeof (struct elf_aarch64_link_hash_table);

 
   ret = bfd_zmalloc (amt);
   if (ret == NULL)
 
   ret = bfd_zmalloc (amt);
   if (ret == NULL)


@@ -3278,7 +3278,7 @@ _bfd_aarch64_add_stub_entry_after (const char *stub_name,
 
 static bfd_boolean
 aarch64_build_one_stub (struct bfd_hash_entry *gen_entry,
 
 static bfd_boolean
 aarch64_build_one_stub (struct bfd_hash_entry *gen_entry,

-                       void *in_arg ATTRIBUTE_UNUSED)
+                       void *in_arg)

 {
   struct elf_aarch64_stub_hash_entry *stub_entry;
   asection *stub_sec;
 {
   struct elf_aarch64_stub_hash_entry *stub_entry;
   asection *stub_sec;


@@ -3291,10 +3291,22 @@ aarch64_build_one_stub (struct bfd_hash_entry *gen_entry,
   unsigned int template_size;
   const uint32_t *template;
   unsigned int i;
   unsigned int template_size;
   const uint32_t *template;
   unsigned int i;

+  struct bfd_link_info *info;

 
   /* Massage our args to the form they really have.  */
   stub_entry = (struct elf_aarch64_stub_hash_entry *) gen_entry;
 
 
   /* Massage our args to the form they really have.  */
   stub_entry = (struct elf_aarch64_stub_hash_entry *) gen_entry;
 

+  info = (struct bfd_link_info *) in_arg;
+
+  /* Fail if the target section could not be assigned to an output
+     section.  The user should fix his linker script.  */
+  if (stub_entry->target_section->output_section == NULL
+      && info->non_contiguous_regions)
+    info->callbacks->einfo (_("%F%P: Could not assign '%pA' to an output section. "
+                             "Retry without "
+                             "--enable-non-contiguous-regions.\n"),
+                           stub_entry->target_section);
+

   stub_sec = stub_entry->stub_sec;
 
   /* Make a note of the offset within the stubs for this entry.  */
   stub_sec = stub_entry->stub_sec;
 
   /* Make a note of the offset within the stubs for this entry.  */


@@ -3456,7 +3468,7 @@ elfNN_aarch64_setup_section_lists (bfd *output_bfd,
   unsigned int top_id, top_index;
   asection *section;
   asection **input_list, **list;
   unsigned int top_id, top_index;
   asection *section;
   asection **input_list, **list;

-  bfd_size_type amt;
+  size_t amt;

   struct elf_aarch64_link_hash_table *htab =
     elf_aarch64_hash_table (info);
 
   struct elf_aarch64_link_hash_table *htab =
     elf_aarch64_hash_table (info);
 


@@ -3534,7 +3546,7 @@ elfNN_aarch64_next_input_section (struct bfd_link_info *info, asection *isec)
     {
       asection **list = htab->input_list + isec->output_section->index;
 
     {
       asection **list = htab->input_list + isec->output_section->index;
 

-      if (*list != bfd_abs_section_ptr)
+      if (*list != bfd_abs_section_ptr && (isec->flags & SEC_CODE) != 0)

        {
          /* Steal the link_sec pointer for our list.  */
          /* This happens to make the list in reverse order,
        {
          /* Steal the link_sec pointer for our list.  */
          /* This happens to make the list in reverse order,


@@ -3555,67 +3567,96 @@ elfNN_aarch64_next_input_section (struct bfd_link_info *info, asection *isec)
 static void
 group_sections (struct elf_aarch64_link_hash_table *htab,
                bfd_size_type stub_group_size,
 static void
 group_sections (struct elf_aarch64_link_hash_table *htab,
                bfd_size_type stub_group_size,

-               bfd_boolean stubs_always_before_branch)
+               bfd_boolean stubs_always_after_branch)

 {
 {

-  asection **list = htab->input_list + htab->top_index;
+  asection **list = htab->input_list;

 
   do
     {
       asection *tail = *list;
 
   do
     {
       asection *tail = *list;

+      asection *head;

 
       if (tail == bfd_abs_section_ptr)
        continue;
 
 
       if (tail == bfd_abs_section_ptr)
        continue;
 

+      /* Reverse the list: we must avoid placing stubs at the
+        beginning of the section because the beginning of the text
+        section may be required for an interrupt vector in bare metal
+        code.  */
+#define NEXT_SEC PREV_SEC
+      head = NULL;

       while (tail != NULL)
       while (tail != NULL)

+       {
+         /* Pop from tail.  */
+         asection *item = tail;
+         tail = PREV_SEC (item);
+
+         /* Push on head.  */
+         NEXT_SEC (item) = head;
+         head = item;
+       }
+
+      while (head != NULL)

        {
          asection *curr;
        {
          asection *curr;

-         asection *prev;
-         bfd_size_type total;
+         asection *next;
+         bfd_vma stub_group_start = head->output_offset;
+         bfd_vma end_of_next;

 
 

-         curr = tail;
-         total = tail->size;
-         while ((prev = PREV_SEC (curr)) != NULL
-                && ((total += curr->output_offset - prev->output_offset)
-                    < stub_group_size))
-           curr = prev;
+         curr = head;
+         while (NEXT_SEC (curr) != NULL)
+           {
+             next = NEXT_SEC (curr);
+             end_of_next = next->output_offset + next->size;
+             if (end_of_next - stub_group_start >= stub_group_size)
+               /* End of NEXT is too far from start, so stop.  */
+               break;
+             /* Add NEXT to the group.  */
+             curr = next;
+           }

 
 

-         /* OK, the size from the start of CURR to the end is less
+         /* OK, the size from the start to the start of CURR is less

             than stub_group_size and thus can be handled by one stub
             than stub_group_size and thus can be handled by one stub

-            section.  (Or the tail section is itself larger than
+            section.  (Or the head section is itself larger than

             stub_group_size, in which case we may be toast.)
             We should really be keeping track of the total size of
             stubs added here, as stubs contribute to the final output
             section size.  */
          do
            {
             stub_group_size, in which case we may be toast.)
             We should really be keeping track of the total size of
             stubs added here, as stubs contribute to the final output
             section size.  */
          do
            {

-             prev = PREV_SEC (tail);
+             next = NEXT_SEC (head);

              /* Set up this stub group.  */
              /* Set up this stub group.  */

-             htab->stub_group[tail->id].link_sec = curr;
+             htab->stub_group[head->id].link_sec = curr;

            }
            }

-         while (tail != curr && (tail = prev) != NULL);
+         while (head != curr && (head = next) != NULL);

 
          /* But wait, there's more!  Input sections up to stub_group_size
 
          /* But wait, there's more!  Input sections up to stub_group_size

-            bytes before the stub section can be handled by it too.  */
-         if (!stubs_always_before_branch)
+            bytes after the stub section can be handled by it too.  */
+         if (!stubs_always_after_branch)

            {
            {

-             total = 0;
-             while (prev != NULL
-                    && ((total += tail->output_offset - prev->output_offset)
-                        < stub_group_size))
+             stub_group_start = curr->output_offset + curr->size;
+
+             while (next != NULL)

                {
                {

-                 tail = prev;
-                 prev = PREV_SEC (tail);
-                 htab->stub_group[tail->id].link_sec = curr;
+                 end_of_next = next->output_offset + next->size;
+                 if (end_of_next - stub_group_start >= stub_group_size)
+                   /* End of NEXT is too far from stubs, so stop.  */
+                   break;
+                 /* Add NEXT to the stub group.  */
+                 head = next;
+                 next = NEXT_SEC (head);
+                 htab->stub_group[head->id].link_sec = curr;

                }
            }
                }
            }

-         tail = prev;
+         head = next;

        }
     }
        }
     }

-  while (list-- != htab->input_list);
+  while (list++ != htab->input_list + htab->top_index);

 
   free (htab->input_list);
 }
 
 
   free (htab->input_list);
 }
 

+#undef PREV_SEC

 #undef PREV_SEC
 
 #define AARCH64_BITS(x, pos, n) (((x) >> (pos)) & ((1 << (n)) - 1))
 #undef PREV_SEC
 
 #define AARCH64_BITS(x, pos, n) (((x) >> (pos)) & ((1 << (n)) - 1))


@@ -4313,9 +4354,15 @@ elfNN_aarch64_size_stubs (bfd *output_bfd,
 
       for (input_bfd = info->input_bfds;
           input_bfd != NULL; input_bfd = input_bfd->link.next)
 
       for (input_bfd = info->input_bfds;
           input_bfd != NULL; input_bfd = input_bfd->link.next)

-       if (!_bfd_aarch64_erratum_835769_scan (input_bfd, info,
-                                              &num_erratum_835769_fixes))
-         return FALSE;
+       {
+         if (!is_aarch64_elf (input_bfd)
+             || (input_bfd->flags & BFD_LINKER_CREATED) != 0)
+           continue;
+
+         if (!_bfd_aarch64_erratum_835769_scan (input_bfd, info,
+                                                &num_erratum_835769_fixes))
+           return FALSE;
+       }

 
       _bfd_aarch64_resize_stubs (htab);
       (*htab->layout_sections_again) ();
 
       _bfd_aarch64_resize_stubs (htab);
       (*htab->layout_sections_again) ();


@@ -4331,6 +4378,10 @@ elfNN_aarch64_size_stubs (bfd *output_bfd,
        {
          asection *section;
 
        {
          asection *section;
 

+         if (!is_aarch64_elf (input_bfd)
+             || (input_bfd->flags & BFD_LINKER_CREATED) != 0)
+           continue;
+

          for (section = input_bfd->sections;
               section != NULL;
               section = section->next)
          for (section = input_bfd->sections;
               section != NULL;
               section = section->next)


@@ -4353,6 +4404,10 @@ elfNN_aarch64_size_stubs (bfd *output_bfd,
          asection *section;
          Elf_Internal_Sym *local_syms = NULL;
 
          asection *section;
          Elf_Internal_Sym *local_syms = NULL;
 

+         if (!is_aarch64_elf (input_bfd)
+             || (input_bfd->flags & BFD_LINKER_CREATED) != 0)
+           continue;
+

          /* We'll need the symbol table in a second.  */
          symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
          if (symtab_hdr->sh_info == 0)
          /* We'll need the symbol table in a second.  */
          symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
          if (symtab_hdr->sh_info == 0)


@@ -4615,7 +4670,7 @@ elfNN_aarch64_size_stubs (bfd *output_bfd,
 
   return TRUE;
 
 
   return TRUE;
 

-error_ret_free_local:
+ error_ret_free_local:

   return FALSE;
 }
 
   return FALSE;
 }
 


@@ -5439,6 +5494,7 @@ elfNN_aarch64_final_link_relocate (reloc_howto_type *howto,
   bfd_vma orig_value = value;
   bfd_boolean resolved_to_zero;
   bfd_boolean abs_symbol_p;
   bfd_vma orig_value = value;
   bfd_boolean resolved_to_zero;
   bfd_boolean abs_symbol_p;

+  bfd_boolean via_plt_p;

 
   globals = elf_aarch64_hash_table (info);
 
 
   globals = elf_aarch64_hash_table (info);
 


@@ -5460,6 +5516,8 @@ elfNN_aarch64_final_link_relocate (reloc_howto_type *howto,
                  : bfd_is_und_section (sym_sec));
   abs_symbol_p = h != NULL && bfd_is_abs_symbol (&h->root);
 
                  : bfd_is_und_section (sym_sec));
   abs_symbol_p = h != NULL && bfd_is_abs_symbol (&h->root);
 

+  via_plt_p = (globals->root.splt != NULL && h != NULL
+              && h->plt.offset != (bfd_vma) - 1);

 
   /* Since STT_GNU_IFUNC symbol must go through PLT, we handle
      it here if it is defined in a non-shared object.  */
 
   /* Since STT_GNU_IFUNC symbol must go through PLT, we handle
      it here if it is defined in a non-shared object.  */


@@ -5507,7 +5565,7 @@ elfNN_aarch64_final_link_relocate (reloc_howto_type *howto,
       switch (bfd_r_type)
        {
        default:
       switch (bfd_r_type)
        {
        default:

-bad_ifunc_reloc:
+       bad_ifunc_reloc:

          if (h->root.root.string)
            name = h->root.root.string;
          else
          if (h->root.root.string)
            name = h->root.root.string;
          else


@@ -5795,12 +5853,23 @@ bad_ifunc_reloc:
        value += signed_addend;
       break;
 
        value += signed_addend;
       break;
 

+    case BFD_RELOC_AARCH64_BRANCH19:
+    case BFD_RELOC_AARCH64_TSTBR14:
+      /* A conditional branch to an undefined weak symbol is converted to a
+        branch to itself.  */
+      if (weak_undef_p && !via_plt_p)
+       {
+         value = _bfd_aarch64_elf_resolve_relocation (input_bfd, bfd_r_type,
+                                                      place, value,
+                                                      signed_addend,
+                                                      weak_undef_p);
+         break;
+       }
+      /* Fall through.  */

     case BFD_RELOC_AARCH64_CALL26:
     case BFD_RELOC_AARCH64_JUMP26:
       {
        asection *splt = globals->root.splt;
     case BFD_RELOC_AARCH64_CALL26:
     case BFD_RELOC_AARCH64_JUMP26:
       {
        asection *splt = globals->root.splt;

-       bfd_boolean via_plt_p =
-         splt != NULL && h != NULL && h->plt.offset != (bfd_vma) - 1;

 
        /* A call to an undefined weak symbol is converted to a jump to
           the next instruction unless a PLT entry will be created.
 
        /* A call to an undefined weak symbol is converted to a jump to
           the next instruction unless a PLT entry will be created.


@@ -5888,7 +5957,6 @@ bad_ifunc_reloc:
     case BFD_RELOC_AARCH64_32:
 #endif
     case BFD_RELOC_AARCH64_ADD_LO12:
     case BFD_RELOC_AARCH64_32:
 #endif
     case BFD_RELOC_AARCH64_ADD_LO12:

-    case BFD_RELOC_AARCH64_BRANCH19:

     case BFD_RELOC_AARCH64_LDST128_LO12:
     case BFD_RELOC_AARCH64_LDST16_LO12:
     case BFD_RELOC_AARCH64_LDST32_LO12:
     case BFD_RELOC_AARCH64_LDST128_LO12:
     case BFD_RELOC_AARCH64_LDST16_LO12:
     case BFD_RELOC_AARCH64_LDST32_LO12:


@@ -5904,7 +5972,6 @@ bad_ifunc_reloc:
     case BFD_RELOC_AARCH64_MOVW_G2_NC:
     case BFD_RELOC_AARCH64_MOVW_G2_S:
     case BFD_RELOC_AARCH64_MOVW_G3:
     case BFD_RELOC_AARCH64_MOVW_G2_NC:
     case BFD_RELOC_AARCH64_MOVW_G2_S:
     case BFD_RELOC_AARCH64_MOVW_G3:

-    case BFD_RELOC_AARCH64_TSTBR14:

       value = _bfd_aarch64_elf_resolve_relocation (input_bfd, bfd_r_type,
                                                   place, value,
                                                   signed_addend, weak_undef_p);
       value = _bfd_aarch64_elf_resolve_relocation (input_bfd, bfd_r_type,
                                                   place, value,
                                                   signed_addend, weak_undef_p);


@@ -7853,7 +7920,7 @@ elfNN_aarch64_check_relocs (bfd *abfd, struct bfd_link_info *info,
            p = *head;
            if (p == NULL || p->sec != sec)
              {
            p = *head;
            if (p == NULL || p->sec != sec)
              {

-               bfd_size_type amt = sizeof *p;
+               size_t amt = sizeof *p;

                p = ((struct elf_dyn_relocs *)
                     bfd_zalloc (htab->root.dynobj, amt));
                if (p == NULL)
                p = ((struct elf_dyn_relocs *)
                     bfd_zalloc (htab->root.dynobj, amt));
                if (p == NULL)


@@ -7967,6 +8034,8 @@ elfNN_aarch64_check_relocs (bfd *abfd, struct bfd_link_info *info,
            break;
          }
 
            break;
          }
 

+       case BFD_RELOC_AARCH64_BRANCH19:
+       case BFD_RELOC_AARCH64_TSTBR14:

        case BFD_RELOC_AARCH64_CALL26:
        case BFD_RELOC_AARCH64_JUMP26:
          /* If this is a local symbol then we resolve it
        case BFD_RELOC_AARCH64_CALL26:
        case BFD_RELOC_AARCH64_JUMP26:
          /* If this is a local symbol then we resolve it


@@ -8419,7 +8488,7 @@ elfNN_aarch64_new_section_hook (bfd *abfd, asection *sec)
   if (!sec->used_by_bfd)
     {
       _aarch64_elf_section_data *sdata;
   if (!sec->used_by_bfd)
     {
       _aarch64_elf_section_data *sdata;

-      bfd_size_type amt = sizeof (*sdata);
+      size_t amt = sizeof (*sdata);

 
       sdata = bfd_zalloc (abfd, amt);
       if (sdata == NULL)
 
       sdata = bfd_zalloc (abfd, amt);
       if (sdata == NULL)


@@ -9482,7 +9551,7 @@ elfNN_aarch64_finish_dynamic_symbol (bfd *output_bfd,
        }
       else
        {
        }
       else
        {

-do_glob_dat:
+       do_glob_dat:

          BFD_ASSERT ((h->got.offset & 1) == 0);
          bfd_put_NN (output_bfd, (bfd_vma) 0,
                      htab->root.sgot->contents + h->got.offset);
          BFD_ASSERT ((h->got.offset & 1) == 0);
          bfd_put_NN (output_bfd, (bfd_vma) 0,
                      htab->root.sgot->contents + h->got.offset);