bfd/arc-got.h

   1 /* ARC-specific support for 32-bit ELF
   2    Copyright (C) 1994-2023 Free Software Foundation, Inc.
   3    Contributed by Cupertino Miranda (cmiranda@synopsys.com).
   4
   5    This file is part of BFD, the Binary File Descriptor library.
   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 #ifndef ARC_GOT_H
  23 #define ARC_GOT_H
  24
  25 #define TCB_SIZE (8)
  26
  27 #define align_power(addr, align)        \
  28   (((addr) + ((bfd_vma) 1 << (align)) - 1) & (-((bfd_vma) 1 << (align))))
  29
  30 enum tls_type_e
  31 {
  32   GOT_UNKNOWN = 0,
  33   GOT_NORMAL,
  34   GOT_TLS_GD,
  35   GOT_TLS_IE,
  36   GOT_TLS_LE
  37 };
  38
  39 enum tls_got_entries
  40 {
  41   TLS_GOT_NONE = 0,
  42   TLS_GOT_MOD,
  43   TLS_GOT_OFF,
  44   TLS_GOT_MOD_AND_OFF
  45 };
  46
  47 struct got_entry
  48 {
  49   struct got_entry *next;
  50   enum tls_type_e type;
  51   bfd_vma offset;
  52   bool processed;
  53   bool created_dyn_relocation;
  54   enum tls_got_entries existing_entries;
  55 };
  56
  57 /* Return the local got list, if not defined, create an empty one.  */
  58
  59 static struct got_entry **
  60 arc_get_local_got_ents (bfd * abfd)
  61 {
  62   if (elf_local_got_ents (abfd) == NULL)
  63     {
  64       bfd_size_type amt = (elf_tdata (abfd)->symtab_hdr.sh_info
  65                            * sizeof (*elf_local_got_ents (abfd)));
  66       elf_local_got_ents (abfd) = bfd_zmalloc (amt);
  67       if (elf_local_got_ents (abfd) == NULL)
  68         {
  69           _bfd_error_handler (_("%pB: cannot allocate memory for local "
  70                                 "GOT entries"), abfd);
  71           bfd_set_error (bfd_error_bad_value);
  72           return NULL;
  73         }
  74     }
  75
  76   return elf_local_got_ents (abfd);
  77 }
  78
  79 static struct got_entry *
  80 got_entry_for_type (struct got_entry **list,
  81                     enum tls_type_e type)
  82 {
  83   struct got_entry **p = list;
  84
  85   while (*p != NULL)
  86     {
  87       if ((*p)->type == type)
  88         return *p;
  89       p = &((*p)->next);
  90     }
  91   return NULL;
  92 }
  93
  94 static void
  95 new_got_entry_to_list (struct got_entry **list,
  96                        enum tls_type_e type,
  97                        bfd_vma offset,
  98                        enum tls_got_entries existing_entries)
  99 {
 100   /* Find list end.  Avoid having multiple entries of the same
 101      type.  */
 102   struct got_entry **p = list;
 103   struct got_entry *entry;
 104
 105   while (*p != NULL)
 106     {
 107       if ((*p)->type == type)
 108         return;
 109       p = &((*p)->next);
 110     }
 111
 112   entry = (struct got_entry *) xmalloc (sizeof (struct got_entry));
 113
 114   entry->type = type;
 115   entry->offset = offset;
 116   entry->next = NULL;
 117   entry->processed = false;
 118   entry->created_dyn_relocation = false;
 119   entry->existing_entries = existing_entries;
 120
 121   ARC_DEBUG ("New GOT got entry added to list: "
 122              "type: %d, offset: %ld, existing_entries: %d\n",
 123              type, (long) offset, existing_entries);
 124
 125   /* Add the entry to the end of the list.  */
 126   *p = entry;
 127 }
 128
 129 static enum tls_type_e
 130 tls_type_for_reloc (reloc_howto_type *howto)
 131 {
 132   enum tls_type_e ret = GOT_UNKNOWN;
 133
 134   if (is_reloc_for_GOT (howto))
 135     return GOT_NORMAL;
 136
 137   switch (howto->type)
 138     {
 139     case R_ARC_TLS_GD_GOT:
 140       ret = GOT_TLS_GD;
 141       break;
 142     case R_ARC_TLS_IE_GOT:
 143       ret = GOT_TLS_IE;
 144       break;
 145     case R_ARC_TLS_LE_32:
 146       ret = GOT_TLS_LE;
 147       break;
 148     default:
 149       ret = GOT_UNKNOWN;
 150       break;
 151     }
 152
 153   return ret;
 154 };
 155
 156 static struct got_entry **
 157 get_got_entry_list_for_symbol (bfd *abfd,
 158                                unsigned long r_symndx,
 159                                struct elf_link_hash_entry *h)
 160 {
 161   struct elf_arc_link_hash_entry *h1 =
 162     ((struct elf_arc_link_hash_entry *) h);
 163   if (h1 != NULL)
 164     {
 165       return &h1->got_ents;
 166     }
 167   else
 168     {
 169       return arc_get_local_got_ents (abfd) + r_symndx;
 170     }
 171 }
 172
 173
 174 static enum tls_type_e
 175 arc_got_entry_type_for_reloc (reloc_howto_type *howto)
 176 {
 177   enum tls_type_e type = GOT_UNKNOWN;
 178
 179   if (is_reloc_for_GOT (howto))
 180     return  GOT_NORMAL;
 181
 182   if (is_reloc_for_TLS (howto))
 183     {
 184       switch (howto->type)
 185         {
 186           case R_ARC_TLS_GD_GOT:
 187             type = GOT_TLS_GD;
 188             break;
 189           case R_ARC_TLS_IE_GOT:
 190             type = GOT_TLS_IE;
 191             break;
 192           default:
 193             break;
 194         }
 195     }
 196   return type;
 197 }
 198
 199 #define ADD_SYMBOL_REF_SEC_AND_RELOC(SECNAME, COND_FOR_RELOC, H)        \
 200   htab->s##SECNAME->size;                                               \
 201   {                                                                     \
 202     if (COND_FOR_RELOC)                                                 \
 203       {                                                                 \
 204         htab->srel##SECNAME->size += sizeof (Elf32_External_Rela);      \
 205           ARC_DEBUG ("arc_info: Added reloc space in "                  \
 206                      #SECNAME " section at " __FILE__                   \
 207                      ":%d for symbol %s\n",                             \
 208                      __LINE__, name_for_global_symbol (H));             \
 209       }                                                                 \
 210     if (H)                                                              \
 211       if (H->dynindx == -1 && !H->forced_local)                         \
 212         if (! bfd_elf_link_record_dynamic_symbol (info, H))             \
 213           return false;                                                 \
 214      htab->s##SECNAME->size += 4;                                       \
 215    }                                                                    \
 216
 217 static bool
 218 arc_fill_got_info_for_reloc (enum tls_type_e type,
 219                              struct got_entry **list,
 220                              struct bfd_link_info *  info,
 221                              struct elf_link_hash_entry *h)
 222 {
 223   struct elf_link_hash_table *htab = elf_hash_table (info);
 224
 225   if (got_entry_for_type (list, type) != NULL)
 226     return true;
 227
 228   switch (type)
 229     {
 230       case GOT_NORMAL:
 231         {
 232           bfd_vma offset
 233             = ADD_SYMBOL_REF_SEC_AND_RELOC (got, bfd_link_pic (info)
 234                                                  || h != NULL, h);
 235           new_got_entry_to_list (list, type, offset, TLS_GOT_NONE);
 236         }
 237         break;
 238
 239
 240       case GOT_TLS_GD:
 241         {
 242           bfd_vma offset
 243             = ADD_SYMBOL_REF_SEC_AND_RELOC (got, true, h);
 244           bfd_vma ATTRIBUTE_UNUSED notneeded
 245             = ADD_SYMBOL_REF_SEC_AND_RELOC (got, true, h);
 246           new_got_entry_to_list (list, type, offset, TLS_GOT_MOD_AND_OFF);
 247         }
 248         break;
 249       case GOT_TLS_IE:
 250       case GOT_TLS_LE:
 251         {
 252           bfd_vma offset
 253             = ADD_SYMBOL_REF_SEC_AND_RELOC (got, true, h);
 254           new_got_entry_to_list (list, type, offset, TLS_GOT_OFF);
 255         }
 256         break;
 257
 258       default:
 259         return false;
 260         break;
 261     }
 262   return true;
 263 }
 264
 265 struct arc_static_sym_data {
 266   bfd_vma sym_value;
 267   const char *symbol_name;
 268 };
 269
 270 static struct arc_static_sym_data
 271 get_static_sym_data (unsigned long  r_symndx,
 272                      Elf_Internal_Sym  *local_syms,
 273                      asection **local_sections,
 274                      struct elf_link_hash_entry *h,
 275                      struct arc_relocation_data *reloc_data)
 276 {
 277   static const char local_name[] = "(local)";
 278   struct arc_static_sym_data ret = { 0, NULL };
 279
 280   if (h != NULL)
 281     {
 282       BFD_ASSERT (h->root.type != bfd_link_hash_undefweak
 283                   && h->root.type != bfd_link_hash_undefined);
 284       /* TODO: This should not be here.  */
 285       reloc_data->sym_value = h->root.u.def.value;
 286       reloc_data->sym_section = h->root.u.def.section;
 287
 288       ret.sym_value = h->root.u.def.value
 289         + h->root.u.def.section->output_section->vma
 290         + h->root.u.def.section->output_offset;
 291
 292       ret.symbol_name = h->root.root.string;
 293     }
 294   else
 295   {
 296     Elf_Internal_Sym *sym = local_syms + r_symndx;
 297     asection *sec = local_sections[r_symndx];
 298
 299     ret.sym_value = sym->st_value
 300       + sec->output_section->vma
 301       + sec->output_offset;
 302
 303     ret.symbol_name = local_name;
 304   }
 305   return ret;
 306 }
 307
 308 static bfd_vma
 309 relocate_fix_got_relocs_for_got_info (struct got_entry **          list_p,
 310                                       enum tls_type_e              type,
 311                                       struct bfd_link_info *       info,
 312                                       bfd *                        output_bfd,
 313                                       unsigned long                r_symndx,
 314                                       Elf_Internal_Sym *           local_syms,
 315                                       asection **                  local_sections,
 316                                       struct elf_link_hash_entry * h,
 317                                       struct arc_relocation_data * reloc_data)
 318 {
 319   struct elf_link_hash_table *htab = elf_hash_table (info);
 320   struct got_entry *entry = NULL;
 321
 322   if (list_p == NULL || type == GOT_UNKNOWN || type == GOT_TLS_LE)
 323     return 0;
 324
 325   entry = got_entry_for_type (list_p, type);
 326   BFD_ASSERT (entry);
 327
 328   if (h == NULL
 329       || h->forced_local == true
 330       || (! elf_hash_table (info)->dynamic_sections_created
 331           || (bfd_link_pic (info)
 332               && SYMBOL_REFERENCES_LOCAL (info, h))))
 333     {
 334       const char ATTRIBUTE_UNUSED *symbol_name;
 335       asection *tls_sec = elf_hash_table (info)->tls_sec;
 336
 337       if (entry && !entry->processed)
 338         {
 339           switch (entry->type)
 340             {
 341             case GOT_TLS_GD:
 342               {
 343                 BFD_ASSERT (tls_sec && tls_sec->output_section);
 344                 bfd_vma sec_vma = tls_sec->output_section->vma;
 345
 346                 if (h == NULL || h->forced_local
 347                    || !elf_hash_table (info)->dynamic_sections_created)
 348                   {
 349                     struct arc_static_sym_data tmp =
 350                       get_static_sym_data (r_symndx, local_syms, local_sections,
 351                                            h, reloc_data);
 352
 353                     bfd_put_32 (output_bfd,
 354                             tmp.sym_value - sec_vma
 355                             + (elf_hash_table (info)->dynamic_sections_created
 356                                ? 0
 357                                : (align_power (0,
 358                                                tls_sec->alignment_power))),
 359                             htab->sgot->contents + entry->offset
 360                             + (entry->existing_entries == TLS_GOT_MOD_AND_OFF
 361                                ? 4 : 0));
 362
 363                     ARC_DEBUG ("arc_info: FIXED -> %s value = %#lx "
 364                           "@ %lx, for symbol %s\n",
 365                           (entry->type == GOT_TLS_GD ? "GOT_TLS_GD" :
 366                            "GOT_TLS_IE"),
 367                           (long) (sym_value - sec_vma),
 368                           (long) (htab->sgot->output_section->vma
 369                              + htab->sgot->output_offset
 370                              + entry->offset
 371                              + (entry->existing_entries == TLS_GOT_MOD_AND_OFF
 372                                 ? 4 : 0)),
 373                           tmp.symbol_name);
 374                   }
 375               }
 376               break;
 377
 378             case GOT_TLS_IE:
 379               {
 380                 BFD_ASSERT (tls_sec && tls_sec->output_section);
 381                 bfd_vma ATTRIBUTE_UNUSED sec_vma
 382                   = tls_sec->output_section->vma;
 383
 384                 struct arc_static_sym_data tmp =
 385                   get_static_sym_data (r_symndx, local_syms, local_sections,
 386                                        h, reloc_data);
 387
 388                 bfd_put_32 (output_bfd,
 389                             tmp.sym_value - sec_vma
 390                             + (elf_hash_table (info)->dynamic_sections_created
 391                                ? 0
 392                                : (align_power (TCB_SIZE,
 393                                                tls_sec->alignment_power))),
 394                             htab->sgot->contents + entry->offset
 395                             + (entry->existing_entries == TLS_GOT_MOD_AND_OFF
 396                                ? 4 : 0));
 397
 398                 ARC_DEBUG ("arc_info: FIXED -> %s value = %#lx "
 399                            "@ %p, for symbol %s\n",
 400                            (entry->type == GOT_TLS_GD ? "GOT_TLS_GD" :
 401                             "GOT_TLS_IE"),
 402                            (long) (sym_value - sec_vma),
 403                            (long) (htab->sgot->output_section->vma
 404                               + htab->sgot->output_offset
 405                               + entry->offset
 406                               + (entry->existing_entries == TLS_GOT_MOD_AND_OFF
 407                                  ? 4 : 0)),
 408                            tmp.symbol_name);
 409               }
 410               break;
 411
 412             case GOT_NORMAL:
 413               {
 414                 bfd_vma sec_vma
 415                   = reloc_data->sym_section->output_section->vma
 416                   + reloc_data->sym_section->output_offset;
 417
 418                 if (h != NULL
 419                     && h->root.type == bfd_link_hash_undefweak)
 420                   ARC_DEBUG ("arc_info: PATCHED: NOT_PATCHED "
 421                              "@ %#08lx for sym %s in got offset %#lx "
 422                              "(is undefweak)\n",
 423                              (long) (htab->sgot->output_section->vma
 424                                      + htab->sgot->output_offset
 425                                      + entry->offset),
 426                              symbol_name,
 427                              (long) entry->offset);
 428                 else
 429                   {
 430                     bfd_put_32 (output_bfd,
 431                                 reloc_data->sym_value + sec_vma,
 432                                 htab->sgot->contents + entry->offset);
 433                     ARC_DEBUG ("arc_info: PATCHED: %#08lx "
 434                                "@ %#08lx for sym %s in got offset %#lx\n",
 435                                (long) (reloc_data->sym_value + sec_vma),
 436                                (long) (htab->sgot->output_section->vma
 437                                        + htab->sgot->output_offset
 438                                        + entry->offset),
 439                                symbol_name,
 440                                (long) entry->offset);
 441                   }
 442               }
 443               break;
 444             default:
 445               BFD_ASSERT (0);
 446               break;
 447             }
 448           entry->processed = true;
 449         }
 450     }
 451
 452   return entry->offset;
 453 }
 454
 455 static void
 456 create_got_dynrelocs_for_single_entry (struct got_entry *list,
 457                                        bfd *output_bfd,
 458                                        struct bfd_link_info *  info,
 459                                        struct elf_link_hash_entry *h)
 460 {
 461   if (list == NULL)
 462     return;
 463
 464   bfd_vma got_offset = list->offset;
 465
 466   if (list->type == GOT_NORMAL
 467       && !list->created_dyn_relocation)
 468     {
 469       if (bfd_link_pic (info)
 470           && h != NULL
 471               && (info->symbolic || h->dynindx == -1)
 472               && h->def_regular)
 473         {
 474           ADD_RELA (output_bfd, got, got_offset, 0, R_ARC_RELATIVE, 0);
 475         }
 476       /* Do not fully understand the side effects of this condition.
 477          The relocation space might still being reserved.  Perhaps
 478          I should clear its value.  */
 479       else if (h != NULL && h->dynindx != -1)
 480         {
 481           ADD_RELA (output_bfd, got, got_offset, h->dynindx, R_ARC_GLOB_DAT, 0);
 482         }
 483       list->created_dyn_relocation = true;
 484     }
 485   else if (list->existing_entries != TLS_GOT_NONE
 486            && !list->created_dyn_relocation)
 487     {
 488        /* TODO TLS: This is not called for local symbols.
 489           In order to correctly implement TLS, this should also
 490           be called for all local symbols with tls got entries.
 491           Should be moved to relocate_section in order to make it
 492           work for local symbols.  */
 493       struct elf_link_hash_table *htab = elf_hash_table (info);
 494       enum tls_got_entries e = list->existing_entries;
 495
 496       BFD_ASSERT (list->type != GOT_TLS_GD
 497                   || list->existing_entries == TLS_GOT_MOD_AND_OFF);
 498
 499       bfd_vma dynindx = (h == NULL || h->dynindx == -1) ? 0 : h->dynindx;
 500
 501       if (e == TLS_GOT_MOD_AND_OFF || e == TLS_GOT_MOD)
 502         {
 503               ADD_RELA (output_bfd, got, got_offset, dynindx,
 504                         R_ARC_TLS_DTPMOD, 0);
 505               ARC_DEBUG ("arc_info: TLS_DYNRELOC: type = %d, \
 506 GOT_OFFSET = %#lx, GOT_VMA = %#lx, INDEX = %ld, ADDEND = 0x0\n",
 507                          list->type,
 508                          (long) got_offset,
 509                          (long) (htab->sgot->output_section->vma
 510                                  + htab->sgot->output_offset + got_offset),
 511                          (long) dynindx);
 512         }
 513
 514       if (e == TLS_GOT_MOD_AND_OFF || e == TLS_GOT_OFF)
 515         {
 516           bfd_vma addend = 0;
 517           if (list->type == GOT_TLS_IE)
 518           {
 519             addend = bfd_get_32 (output_bfd,
 520                                  htab->sgot->contents + got_offset);
 521           }
 522
 523           ADD_RELA (output_bfd, got,
 524                     got_offset + (e == TLS_GOT_MOD_AND_OFF ? 4 : 0),
 525                     dynindx,
 526                     (list->type == GOT_TLS_IE ? R_ARC_TLS_TPOFF
 527                                               : R_ARC_TLS_DTPOFF),
 528                     addend);
 529
 530           ARC_DEBUG ("arc_info: TLS_DYNRELOC: type = %d, \
 531 GOT_OFFSET = %#lx, GOT_VMA = %#lx, INDEX = %ld, ADDEND = %#lx\n",
 532                      list->type,
 533                      (long) got_offset,
 534                      (long) (htab->sgot->output_section->vma
 535                              + htab->sgot->output_offset + got_offset),
 536                      (long) dynindx, (long) addend);
 537         }
 538       list->created_dyn_relocation = true;
 539     }
 540 }
 541
 542 static void
 543 create_got_dynrelocs_for_got_info (struct got_entry **list_p,
 544                                    bfd *output_bfd,
 545                                    struct bfd_link_info *  info,
 546                                    struct elf_link_hash_entry *h)
 547 {
 548   if (list_p == NULL)
 549     return;
 550
 551   struct got_entry *list = *list_p;
 552   /* Traverse the list of got entries for this symbol.  */
 553   while (list)
 554     {
 555       create_got_dynrelocs_for_single_entry (list, output_bfd, info, h);
 556       list = list->next;
 557     }
 558 }
 559
 560 #undef ADD_SYMBOL_REF_SEC_AND_RELOC
 561
 562 #endif /* ARC_GOT_H */