bfd/elf32-arc.c

   1 /* ARC-specific support for 32-bit ELF
   2    Copyright (C) 1994-2016 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 #include "sysdep.h"
  23 #include "bfd.h"
  24 #include "libbfd.h"
  25 #include "elf-bfd.h"
  26 #include "elf/arc.h"
  27 #include "libiberty.h"
  28 #include "opcode/arc-func.h"
  29 #include "arc-plt.h"
  30
  31 #ifdef DEBUG
  32 # define PR_DEBUG(fmt, args...) fprintf (stderr, fmt, ##args)
  33 #else
  34 # define PR_DEBUG(fmt, args...)
  35 #endif
  36
  37 /* #define ARC_ENABLE_DEBUG 1 */
  38 #ifndef ARC_ENABLE_DEBUG
  39 #define ARC_DEBUG(...)
  40 #else
  41 static char *
  42 name_for_global_symbol (struct elf_link_hash_entry *h)
  43 {
  44   static char *local_str = "(local)";
  45   if (h == NULL)
  46     return local_str;
  47   else
  48     return h->root.root.string;
  49 }
  50 #define ARC_DEBUG(args...) fprintf (stderr, ##args)
  51 #endif
  52
  53
  54 #define ADD_RELA(BFD, SECTION, OFFSET, SYM_IDX, TYPE, ADDEND)           \
  55   {                                                                     \
  56     struct elf_link_hash_table *_htab = elf_hash_table (info);          \
  57     Elf_Internal_Rela _rel;                                             \
  58     bfd_vma _loc;                                                       \
  59                                                                         \
  60     _loc = (bfd_vma) _htab->srel##SECTION->contents                     \
  61       + ((_htab->srel##SECTION->reloc_count)                            \
  62          * sizeof (Elf32_External_Rela));                               \
  63     _htab->srel##SECTION->reloc_count++;                                \
  64     _rel.r_addend = ADDEND;                                             \
  65     _rel.r_offset = (_htab->s##SECTION)->output_section->vma            \
  66       + (_htab->s##SECTION)->output_offset + OFFSET;                    \
  67     _rel.r_info = ELF32_R_INFO (SYM_IDX, TYPE);                         \
  68     bfd_elf32_swap_reloca_out (BFD, &_rel, (bfd_byte *) _loc);          \
  69   }
  70
  71 struct arc_local_data
  72 {
  73   bfd_vma         sdata_begin_symbol_vma;
  74   asection *      sdata_output_section;
  75   bfd_vma         got_symbol_vma;
  76 };
  77
  78 struct arc_local_data global_arc_data =
  79 {
  80   .sdata_begin_symbol_vma = 0,
  81   .sdata_output_section = NULL,
  82   .got_symbol_vma = 0,
  83 };
  84
  85 struct dynamic_sections
  86 {
  87   bfd_boolean     initialized;
  88   asection *      sgot;
  89   asection *      srelgot;
  90   asection *      sgotplt;
  91   asection *      srelgotplt;
  92   asection *      sdyn;
  93   asection *      splt;
  94   asection *      srelplt;
  95 };
  96
  97 enum dyn_section_types
  98 {
  99   got = 0,
 100   relgot,
 101   gotplt,
 102   dyn,
 103   plt,
 104   relplt,
 105   DYN_SECTION_TYPES_END
 106 };
 107
 108 const char * dyn_section_names[DYN_SECTION_TYPES_END] =
 109 {
 110   ".got",
 111   ".rela.got",
 112   ".got.plt",
 113   ".dynamic",
 114   ".plt",
 115   ".rela.plt"
 116 };
 117
 118 enum tls_type_e
 119 {
 120   GOT_UNKNOWN = 0,
 121   GOT_NORMAL,
 122   GOT_TLS_GD,
 123   GOT_TLS_IE,
 124   GOT_TLS_LE
 125 };
 126
 127 enum tls_got_entries
 128 {
 129   NONE = 0,
 130   MOD,
 131   OFF,
 132   MOD_AND_OFF
 133 };
 134
 135 struct got_entry
 136 {
 137   struct got_entry *next;
 138   enum tls_type_e type;
 139   bfd_vma offset;
 140   bfd_boolean processed;
 141   bfd_boolean created_dyn_relocation;
 142   enum tls_got_entries existing_entries;
 143 };
 144
 145 static void
 146 new_got_entry_to_list (struct got_entry **list,
 147                        enum tls_type_e type,
 148                        bfd_vma offset,
 149                        enum tls_got_entries existing_entries)
 150 {
 151   /* Find list end.  Avoid having multiple entries of the same
 152      type.  */
 153   struct got_entry **p = list;
 154   while (*p != NULL)
 155     {
 156       if ((*p)->type == type)
 157         return;
 158       p = &((*p)->next);
 159     }
 160
 161   struct got_entry *entry =
 162                       (struct got_entry *) malloc (sizeof(struct got_entry));
 163
 164   entry->type = type;
 165   entry->offset = offset;
 166   entry->next = NULL;
 167   entry->processed = FALSE;
 168   entry->created_dyn_relocation = FALSE;
 169   entry->existing_entries = existing_entries;
 170
 171   /* Add the entry to the end of the list.  */
 172   *p = entry;
 173 }
 174
 175 static bfd_boolean
 176 symbol_has_entry_of_type (struct got_entry *list, enum tls_type_e type)
 177 {
 178   while (list != NULL)
 179     {
 180       if (list->type == type)
 181         return TRUE;
 182       list = list->next;
 183     }
 184
 185   return FALSE;
 186 }
 187
 188 /* The default symbols representing the init and fini dyn values.
 189    TODO: Check what is the relation of those strings with arclinux.em
 190    and DT_INIT.  */
 191 #define INIT_SYM_STRING "_init"
 192 #define FINI_SYM_STRING "_fini"
 193
 194 char * init_str = INIT_SYM_STRING;
 195 char * fini_str = FINI_SYM_STRING;
 196
 197 #define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
 198       case VALUE: \
 199         return "R_" #TYPE; \
 200         break;
 201
 202 static ATTRIBUTE_UNUSED const char *
 203 reloc_type_to_name (unsigned int type)
 204 {
 205   switch (type)
 206     {
 207       #include "elf/arc-reloc.def"
 208
 209       default:
 210         return "UNKNOWN";
 211         break;
 212     }
 213 }
 214 #undef ARC_RELOC_HOWTO
 215
 216 /* Try to minimize the amount of space occupied by relocation tables
 217    on the ROM (not that the ROM won't be swamped by other ELF overhead).  */
 218
 219 #define USE_REL 1
 220
 221 static ATTRIBUTE_UNUSED bfd_boolean
 222 is_reloc_PC_relative (reloc_howto_type *howto)
 223 {
 224   return (strstr (howto->name, "PC") != NULL) ? TRUE : FALSE;
 225 }
 226
 227 static bfd_boolean
 228 is_reloc_SDA_relative (reloc_howto_type *howto)
 229 {
 230   return (strstr (howto->name, "SDA") != NULL) ? TRUE : FALSE;
 231 }
 232
 233 static bfd_boolean
 234 is_reloc_for_GOT (reloc_howto_type * howto)
 235 {
 236   if (strstr (howto->name, "TLS") != NULL)
 237     return FALSE;
 238   return (strstr (howto->name, "GOT") != NULL) ? TRUE : FALSE;
 239 }
 240
 241 static bfd_boolean
 242 is_reloc_for_PLT (reloc_howto_type * howto)
 243 {
 244   return (strstr (howto->name, "PLT") != NULL) ? TRUE : FALSE;
 245 }
 246
 247 static bfd_boolean
 248 is_reloc_for_TLS (reloc_howto_type *howto)
 249 {
 250   return (strstr (howto->name, "TLS") != NULL) ? TRUE : FALSE;
 251 }
 252
 253 #define arc_bfd_get_8(A,B,C) bfd_get_8(A,B)
 254 #define arc_bfd_get_16(A,B,C) bfd_get_16(A,B)
 255 #define arc_bfd_put_8(A,B,C,D) bfd_put_8(A,B,C)
 256 #define arc_bfd_put_16(A,B,C,D) bfd_put_16(A,B,C)
 257
 258 static long
 259 arc_bfd_get_32 (bfd * abfd, void *loc, asection * input_section)
 260 {
 261   long insn = bfd_get_32 (abfd, loc);
 262
 263   if (!bfd_big_endian (abfd)
 264       && input_section
 265       && (input_section->flags & SEC_CODE))
 266     insn = ((0x0000fffff & insn) << 16) | ((0xffff0000 & insn) >> 16);
 267
 268   return insn;
 269 }
 270
 271 static void
 272 arc_bfd_put_32 (bfd * abfd, long insn, void *loc, asection * input_section)
 273 {
 274   if (!bfd_big_endian (abfd)
 275       && input_section
 276       && (input_section->flags & SEC_CODE))
 277     insn = ((0x0000fffff & insn) << 16) | ((0xffff0000 & insn) >> 16);
 278
 279   bfd_put_32 (abfd, insn, loc);
 280 }
 281
 282 static bfd_reloc_status_type
 283 arc_elf_reloc (bfd *abfd ATTRIBUTE_UNUSED,
 284                arelent *reloc_entry,
 285                asymbol *symbol_in,
 286                void *data ATTRIBUTE_UNUSED,
 287                asection *input_section,
 288                bfd *output_bfd,
 289                char ** error_message ATTRIBUTE_UNUSED)
 290 {
 291   if (output_bfd != NULL)
 292     {
 293       reloc_entry->address += input_section->output_offset;
 294
 295       /* In case of relocateable link and if the reloc is against a
 296          section symbol, the addend needs to be adjusted according to
 297          where the section symbol winds up in the output section.  */
 298       if ((symbol_in->flags & BSF_SECTION_SYM) && symbol_in->section)
 299         reloc_entry->addend += symbol_in->section->output_offset;
 300
 301       return bfd_reloc_ok;
 302     }
 303
 304   return bfd_reloc_continue;
 305 }
 306
 307
 308 #define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
 309   TYPE = VALUE,
 310 enum howto_list
 311 {
 312 #include "elf/arc-reloc.def"
 313   HOWTO_LIST_LAST
 314 };
 315 #undef ARC_RELOC_HOWTO
 316
 317 #define ARC_RELOC_HOWTO(TYPE, VALUE, RSIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
 318   [TYPE] = HOWTO (R_##TYPE, 0, RSIZE, BITSIZE, FALSE, 0, complain_overflow_##OVERFLOW, arc_elf_reloc, "R_" #TYPE, FALSE, 0, 0, FALSE),
 319
 320 static struct reloc_howto_struct elf_arc_howto_table[] =
 321 {
 322 #include "elf/arc-reloc.def"
 323 /* Example of what is generated by the preprocessor.  Currently kept as an
 324    example.
 325  HOWTO (R_ARC_NONE, // Type.
 326     0, // Rightshift.
 327     2, // Size (0 = byte, 1 = short, 2 = long).
 328     32, // Bitsize.
 329     FALSE, // PC_relative.
 330     0, // Bitpos.
 331     complain_overflow_bitfield, // Complain_on_overflow.
 332     bfd_elf_generic_reloc, // Special_function.
 333     "R_ARC_NONE", // Name.
 334     TRUE, // Partial_inplace.
 335     0, // Src_mask.
 336     0, // Dst_mask.
 337     FALSE), // PCrel_offset.
 338 */
 339 };
 340 #undef ARC_RELOC_HOWTO
 341
 342 static void arc_elf_howto_init (void)
 343 {
 344 #define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
 345   elf_arc_howto_table[TYPE].pc_relative = \
 346     (strstr (#FORMULA, " P ") != NULL || strstr (#FORMULA, " PDATA ") != NULL); \
 347   elf_arc_howto_table[TYPE].dst_mask = RELOC_FUNCTION(0, ~0);
 348
 349 #include "elf/arc-reloc.def"
 350 }
 351 #undef ARC_RELOC_HOWTO
 352
 353
 354 #define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
 355   [TYPE] = VALUE,
 356 const int howto_table_lookup[] =
 357 {
 358 #include "elf/arc-reloc.def"
 359 };
 360 #undef ARC_RELOC_HOWTO
 361
 362 static reloc_howto_type *
 363 arc_elf_howto (unsigned int r_type)
 364 {
 365   if (elf_arc_howto_table[R_ARC_32].dst_mask == 0)
 366     arc_elf_howto_init ();
 367   return &elf_arc_howto_table[r_type];
 368 }
 369
 370 /* Map BFD reloc types to ARC ELF reloc types.  */
 371
 372 struct arc_reloc_map
 373 {
 374   bfd_reloc_code_real_type  bfd_reloc_val;
 375   unsigned char             elf_reloc_val;
 376 };
 377
 378 #define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
 379   { BFD_RELOC_##TYPE, R_##TYPE },
 380 static const struct arc_reloc_map arc_reloc_map[] =
 381 {
 382 #include "elf/arc-reloc.def"
 383
 384   {BFD_RELOC_NONE,  R_ARC_NONE},
 385   {BFD_RELOC_8,  R_ARC_8},
 386   {BFD_RELOC_16, R_ARC_16},
 387   {BFD_RELOC_24, R_ARC_24},
 388   {BFD_RELOC_32, R_ARC_32},
 389 };
 390 #undef ARC_RELOC_HOWTO
 391
 392 static reloc_howto_type *
 393 arc_elf32_bfd_reloc_type_lookup (bfd * abfd ATTRIBUTE_UNUSED,
 394                                  bfd_reloc_code_real_type code)
 395 {
 396   unsigned int i;
 397
 398   for (i = ARRAY_SIZE (arc_reloc_map); i--;)
 399     {
 400       if (arc_reloc_map[i].bfd_reloc_val == code)
 401         return arc_elf_howto (arc_reloc_map[i].elf_reloc_val);
 402     }
 403
 404   return NULL;
 405 }
 406
 407 /* Function to set the ELF flag bits.  */
 408 static bfd_boolean
 409 arc_elf_set_private_flags (bfd *abfd, flagword flags)
 410 {
 411   elf_elfheader (abfd)->e_flags = flags;
 412   elf_flags_init (abfd) = TRUE;
 413   return TRUE;
 414 }
 415
 416 /* Print private flags.  */
 417 static bfd_boolean
 418 arc_elf_print_private_bfd_data (bfd *abfd, void * ptr)
 419 {
 420   FILE *file = (FILE *) ptr;
 421   flagword flags;
 422
 423   BFD_ASSERT (abfd != NULL && ptr != NULL);
 424
 425   /* Print normal ELF private data.  */
 426   _bfd_elf_print_private_bfd_data (abfd, ptr);
 427
 428   flags = elf_elfheader (abfd)->e_flags;
 429   fprintf (file, _("private flags = 0x%lx:"), (unsigned long) flags);
 430
 431   switch (flags & EF_ARC_MACH_MSK)
 432     {
 433     case EF_ARC_CPU_GENERIC : fprintf (file, " -mcpu=generic"); break;
 434     case EF_ARC_CPU_ARCV2HS : fprintf (file, " -mcpu=ARCv2HS");    break;
 435     case EF_ARC_CPU_ARCV2EM : fprintf (file, " -mcpu=ARCv2EM");    break;
 436     case E_ARC_MACH_ARC600  : fprintf (file, " -mcpu=ARC600");     break;
 437     case E_ARC_MACH_ARC601  : fprintf (file, " -mcpu=ARC601");     break;
 438     case E_ARC_MACH_ARC700  : fprintf (file, " -mcpu=ARC700");     break;
 439     default:
 440       fprintf (file, "-mcpu=unknown");
 441       break;
 442     }
 443
 444   switch (flags & EF_ARC_OSABI_MSK)
 445     {
 446     case E_ARC_OSABI_ORIG : fprintf (file, " (ABI:legacy)"); break;
 447     case E_ARC_OSABI_V2   : fprintf (file, " (ABI:v2)");     break;
 448     case E_ARC_OSABI_V3   : fprintf (file, " (ABI:v3)");     break;
 449     default:
 450       fprintf (file, "(ABI:unknown)");
 451       break;
 452     }
 453
 454   fputc ('\n', file);
 455   return TRUE;
 456 }
 457
 458 /* Copy backend specific data from one object module to another.  */
 459
 460 static bfd_boolean
 461 arc_elf_copy_private_bfd_data (bfd *ibfd, bfd *obfd)
 462 {
 463   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
 464       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
 465     return TRUE;
 466
 467   BFD_ASSERT (!elf_flags_init (obfd)
 468               || elf_elfheader (obfd)->e_flags == elf_elfheader (ibfd)->e_flags);
 469
 470   elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
 471   elf_flags_init (obfd) = TRUE;
 472
 473   /* Copy object attributes.  */
 474   _bfd_elf_copy_obj_attributes (ibfd, obfd);
 475
 476   return _bfd_elf_copy_private_bfd_data (ibfd, obfd);
 477 }
 478
 479 static reloc_howto_type *
 480 bfd_elf32_bfd_reloc_name_lookup (bfd * abfd ATTRIBUTE_UNUSED,
 481                                  const char *r_name)
 482 {
 483   unsigned int i;
 484
 485   for (i = 0; i < ARRAY_SIZE (elf_arc_howto_table); i++)
 486     if (elf_arc_howto_table[i].name != NULL
 487         && strcasecmp (elf_arc_howto_table[i].name, r_name) == 0)
 488       return arc_elf_howto (i);
 489
 490   return NULL;
 491 }
 492
 493 /* Set the howto pointer for an ARC ELF reloc.  */
 494
 495 static void
 496 arc_info_to_howto_rel (bfd * abfd ATTRIBUTE_UNUSED,
 497                        arelent * cache_ptr,
 498                        Elf_Internal_Rela * dst)
 499 {
 500   unsigned int r_type;
 501
 502   r_type = ELF32_R_TYPE (dst->r_info);
 503   BFD_ASSERT (r_type < (unsigned int) R_ARC_max);
 504   cache_ptr->howto = arc_elf_howto (r_type);
 505 }
 506
 507 /* Merge backend specific data from an object file to the output
 508    object file when linking.  */
 509
 510 static bfd_boolean
 511 arc_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
 512 {
 513   unsigned short mach_ibfd;
 514   static unsigned short mach_obfd = EM_NONE;
 515   flagword out_flags;
 516   flagword in_flags;
 517   asection *sec;
 518
 519    /* Check if we have the same endianess.  */
 520   if (! _bfd_generic_verify_endian_match (ibfd, obfd))
 521     {
 522       _bfd_error_handler (_("ERROR: Endian Match failed. Attempting to link "
 523                             "%B with binary %s of opposite endian-ness"),
 524                           ibfd, bfd_get_filename (obfd));
 525       return FALSE;
 526     }
 527
 528   /* Collect ELF flags.  */
 529   in_flags = elf_elfheader (ibfd)->e_flags & EF_ARC_MACH_MSK;
 530   out_flags = elf_elfheader (obfd)->e_flags & EF_ARC_MACH_MSK;
 531
 532   if (!elf_flags_init (obfd)) /* First call, no flags set.  */
 533     {
 534       elf_flags_init (obfd) = TRUE;
 535       out_flags = in_flags;
 536     }
 537
 538   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
 539       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
 540     return TRUE;
 541
 542   /* Check to see if the input BFD actually contains any sections.  Do
 543      not short-circuit dynamic objects; their section list may be
 544      emptied by elf_link_add_object_symbols.  */
 545   if (!(ibfd->flags & DYNAMIC))
 546     {
 547       bfd_boolean null_input_bfd = TRUE;
 548       bfd_boolean only_data_sections = TRUE;
 549
 550       for (sec = ibfd->sections; sec != NULL; sec = sec->next)
 551         {
 552           if ((bfd_get_section_flags (ibfd, sec)
 553                & (SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS))
 554               == (SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS))
 555             only_data_sections = FALSE;
 556
 557           null_input_bfd = FALSE;
 558         }
 559
 560       if (null_input_bfd || only_data_sections)
 561         return TRUE;
 562     }
 563
 564   /* Complain about various flag/architecture mismatches.  */
 565   mach_ibfd = elf_elfheader (ibfd)->e_machine;
 566   if (mach_obfd == EM_NONE)
 567     {
 568       mach_obfd = mach_ibfd;
 569     }
 570   else
 571     {
 572       if (mach_ibfd != mach_obfd)
 573         {
 574           _bfd_error_handler (_("ERROR: Attempting to link %B "
 575                                 "with a binary %s of different architecture"),
 576                               ibfd, bfd_get_filename (obfd));
 577           return FALSE;
 578         }
 579       else if (in_flags != out_flags)
 580         {
 581           /* Warn if different flags.  */
 582           (*_bfd_error_handler)
 583             (_("%s: uses different e_flags (0x%lx) fields than "
 584                "previous modules (0x%lx)"),
 585              bfd_get_filename (ibfd), (long)in_flags, (long)out_flags);
 586           if (in_flags && out_flags)
 587             return FALSE;
 588           /* MWDT doesnt set the eflags hence make sure we choose the
 589              eflags set by gcc.  */
 590           in_flags = in_flags > out_flags ? in_flags : out_flags;
 591         }
 592     }
 593
 594   /* Update the flags.  */
 595   elf_elfheader (obfd)->e_flags = in_flags;
 596
 597   if (bfd_get_mach (obfd) < bfd_get_mach (ibfd))
 598     {
 599       return bfd_set_arch_mach (obfd, bfd_arch_arc, bfd_get_mach (ibfd));
 600     }
 601
 602   return TRUE;
 603 }
 604
 605 /* Set the right machine number for an ARC ELF file.  */
 606 static bfd_boolean
 607 arc_elf_object_p (bfd * abfd)
 608 {
 609   /* Make sure this is initialised, or you'll have the potential of passing
 610      garbage---or misleading values---into the call to
 611      bfd_default_set_arch_mach ().  */
 612   int             mach = bfd_mach_arc_arc700;
 613   unsigned long   arch = elf_elfheader (abfd)->e_flags & EF_ARC_MACH_MSK;
 614   unsigned        e_machine = elf_elfheader (abfd)->e_machine;
 615
 616   if (e_machine == EM_ARC_COMPACT || e_machine == EM_ARC_COMPACT2)
 617     {
 618       switch (arch)
 619         {
 620           case E_ARC_MACH_ARC600:
 621             mach = bfd_mach_arc_arc600;
 622             break;
 623           case E_ARC_MACH_ARC601:
 624             mach = bfd_mach_arc_arc601;
 625             break;
 626           case E_ARC_MACH_ARC700:
 627             mach = bfd_mach_arc_arc700;
 628             break;
 629           case EF_ARC_CPU_ARCV2HS:
 630           case EF_ARC_CPU_ARCV2EM:
 631             mach = bfd_mach_arc_arcv2;
 632             break;
 633           default:
 634             mach = (e_machine == EM_ARC_COMPACT) ?
 635               bfd_mach_arc_arc700 : bfd_mach_arc_arcv2;
 636             break;
 637         }
 638     }
 639   else
 640     {
 641       if (e_machine == EM_ARC)
 642         {
 643           (*_bfd_error_handler)
 644             (_("Error: The ARC4 architecture is no longer supported.\n"));
 645           return FALSE;
 646         }
 647       else
 648         {
 649           (*_bfd_error_handler)
 650             (_("Warning: unset or old architecture flags. \n"
 651                "               Use default machine.\n"));
 652         }
 653     }
 654
 655   return bfd_default_set_arch_mach (abfd, bfd_arch_arc, mach);
 656 }
 657
 658 /* The final processing done just before writing out an ARC ELF object file.
 659    This gets the ARC architecture right based on the machine number.  */
 660
 661 static void
 662 arc_elf_final_write_processing (bfd * abfd,
 663                                 bfd_boolean linker ATTRIBUTE_UNUSED)
 664 {
 665   unsigned long val;
 666   unsigned long emf;
 667
 668   switch (bfd_get_mach (abfd))
 669     {
 670     case bfd_mach_arc_arc600:
 671       val = E_ARC_MACH_ARC600;
 672       emf = EM_ARC_COMPACT;
 673       break;
 674     case bfd_mach_arc_arc601:
 675       val = E_ARC_MACH_ARC601;
 676       emf = EM_ARC_COMPACT;
 677       break;
 678     case bfd_mach_arc_arc700:
 679       val = E_ARC_MACH_ARC700;
 680       emf = EM_ARC_COMPACT;
 681       break;
 682     case bfd_mach_arc_arcv2:
 683       val = EF_ARC_CPU_GENERIC;
 684       emf = EM_ARC_COMPACT2;
 685       /* TODO: Check validity of this.  It can also be ARCV2EM here.
 686          Previous version sets the e_machine here.  */
 687       break;
 688     default:
 689       abort ();
 690     }
 691
 692   elf_elfheader (abfd)->e_flags &= ~EF_ARC_MACH;
 693   elf_elfheader (abfd)->e_flags |= val;
 694   elf_elfheader (abfd)->e_machine = emf;
 695   /* Record whatever is the current syscall ABI version.  */
 696   elf_elfheader (abfd)->e_flags |= E_ARC_OSABI_CURRENT;
 697 }
 698
 699 #define BFD_DEBUG_PIC(...)
 700
 701 struct arc_relocation_data
 702 {
 703   bfd_vma         reloc_offset;
 704   bfd_vma         reloc_addend;
 705   bfd_vma         got_offset_value;
 706
 707   bfd_vma         sym_value;
 708   asection *      sym_section;
 709
 710   reloc_howto_type *howto;
 711
 712   asection *      input_section;
 713
 714   bfd_vma         sdata_begin_symbol_vma;
 715   bfd_boolean     sdata_begin_symbol_vma_set;
 716   bfd_vma         got_symbol_vma;
 717
 718   bfd_boolean     should_relocate;
 719 };
 720
 721 static void
 722 debug_arc_reloc (struct arc_relocation_data reloc_data)
 723 {
 724   PR_DEBUG ("Reloc type=%s, should_relocate = %s\n",
 725            reloc_data.howto->name,
 726            reloc_data.should_relocate ? "true" : "false");
 727   PR_DEBUG ("  offset = 0x%x, addend = 0x%x\n",
 728            (unsigned int) reloc_data.reloc_offset,
 729            (unsigned int) reloc_data.reloc_addend);
 730   PR_DEBUG (" Symbol:\n");
 731   PR_DEBUG ("  value = 0x%08x\n",
 732            (unsigned int) reloc_data.sym_value);
 733   if (reloc_data.sym_section != NULL)
 734     {
 735       PR_DEBUG ("IN IF\n");
 736       PR_DEBUG (
 737                "  section name = %s, output_offset 0x%08x",
 738                reloc_data.sym_section->name,
 739                (unsigned int) reloc_data.sym_section->output_offset);
 740       if (reloc_data.sym_section->output_section != NULL)
 741         {
 742           PR_DEBUG (
 743                    ", output_section->vma = 0x%08x",
 744                    ((unsigned int) reloc_data.sym_section->output_section->vma));
 745         }
 746
 747       PR_DEBUG ( "\n");
 748     }
 749   else
 750     {
 751       PR_DEBUG ( "  symbol section is NULL\n");
 752     }
 753
 754   PR_DEBUG ( " Input_section:\n");
 755   if (reloc_data.input_section != NULL)
 756     {
 757       PR_DEBUG (
 758                "  section name = %s, output_offset 0x%08x, output_section->vma = 0x%08x\n",
 759                reloc_data.input_section->name,
 760                (unsigned int) reloc_data.input_section->output_offset,
 761                (unsigned int) reloc_data.input_section->output_section->vma);
 762       PR_DEBUG ( "  changed_address = 0x%08x\n",
 763                (unsigned int) (reloc_data.input_section->output_section->vma +
 764                reloc_data.input_section->output_offset +
 765                reloc_data.reloc_offset));
 766     }
 767   else
 768     {
 769       PR_DEBUG ( "      input section is NULL\n");
 770     }
 771 }
 772
 773 static ATTRIBUTE_UNUSED bfd_vma
 774 get_middle_endian_relocation (bfd_vma reloc)
 775 {
 776   bfd_vma ret = ((reloc & 0xffff0000) >> 16) |
 777                 ((reloc & 0xffff) << 16);
 778   return ret;
 779 }
 780
 781 #define S (reloc_data.sym_value                                         \
 782            + (reloc_data.sym_section->output_section != NULL ?          \
 783               (reloc_data.sym_section->output_offset                    \
 784                + reloc_data.sym_section->output_section->vma) : 0)      \
 785            )
 786 #define L (reloc_data.sym_value                                         \
 787            + (reloc_data.sym_section->output_section != NULL ?          \
 788               (reloc_data.sym_section->output_offset                    \
 789               + reloc_data.sym_section->output_section->vma) : 0)       \
 790           )
 791 #define A (reloc_data.reloc_addend)
 792 #define B (0)
 793 #define G (reloc_data.got_offset_value)
 794 #define GOT (reloc_data.got_symbol_vma)
 795 #define GOT_BEGIN (htab->sgot->output_section->vma)
 796
 797 #define MES (0)
 798         /* P: relative offset to PCL The offset should be to the
 799           current location aligned to 32 bits.  */
 800 #define P (                                                             \
 801            (                                                            \
 802             (reloc_data.input_section->output_section != NULL ?         \
 803              reloc_data.input_section->output_section->vma : 0)         \
 804             + reloc_data.input_section->output_offset                   \
 805             + (reloc_data.reloc_offset - (bitsize >= 32 ? 4 : 0))       \
 806             ) & ~0x3)
 807 #define PDATA ( \
 808             (reloc_data.input_section->output_section->vma \
 809              + reloc_data.input_section->output_offset \
 810              + (reloc_data.reloc_offset) \
 811             ))
 812 #define SECTSTAR (reloc_data.input_section->output_offset)
 813 #define SECTSTART (reloc_data.input_section->output_offset)
 814 #define _SDA_BASE_ (reloc_data.sdata_begin_symbol_vma)
 815 #define TLS_REL ((elf_hash_table (info))->tls_sec->output_section->vma)
 816 #define _SDA_BASE_ (reloc_data.sdata_begin_symbol_vma)
 817 #define TLS_TBSS (8)
 818 #define TCB_SIZE (8)
 819
 820 #define NON_ME(VALUE) (reverse_me (reloc_data, VALUE))
 821
 822 #define none (0)
 823
 824 #define PRINT_DEBUG_RELOC_INFO_BEFORE(FORMULA) \
 825     {\
 826       asection *sym_section = reloc_data.sym_section; \
 827       asection *input_section = reloc_data.input_section; \
 828       ARC_DEBUG ("FORMULA = " #FORMULA "\n"); \
 829       ARC_DEBUG ("S = 0x%x\n", S); \
 830       ARC_DEBUG ("A = 0x%x\n", A); \
 831       ARC_DEBUG ("L = 0x%x\n", L); \
 832       if (sym_section->output_section != NULL) \
 833         { \
 834           ARC_DEBUG ("symbol_section->vma = 0x%x\n", \
 835              sym_section->output_section->vma + sym_section->output_offset); \
 836         } \
 837       else \
 838         { \
 839           ARC_DEBUG ("symbol_section->vma = NULL\n"); \
 840         } \
 841       if (input_section->output_section != NULL) \
 842         { \
 843           ARC_DEBUG ("symbol_section->vma = 0x%x\n", \
 844              input_section->output_section->vma + input_section->output_offset); \
 845         } \
 846       else \
 847         { \
 848           ARC_DEBUG ("symbol_section->vma = NULL\n"); \
 849         } \
 850       ARC_DEBUG ("PCL = 0x%x\n", P); \
 851       ARC_DEBUG ("P = 0x%x\n", P); \
 852       ARC_DEBUG ("G = 0x%x\n", G); \
 853       ARC_DEBUG ("SDA_OFFSET = 0x%x\n", _SDA_BASE_); \
 854       ARC_DEBUG ("SDA_SET = %d\n", reloc_data.sdata_begin_symbol_vma_set); \
 855       ARC_DEBUG ("GOT_OFFSET = 0x%x\n", GOT); \
 856       ARC_DEBUG ("relocation = 0x%08x\n", relocation); \
 857       ARC_DEBUG ("before = 0x%08x\n", (unsigned int) insn); \
 858       ARC_DEBUG ("data   = 0x%08x (%u) (%d)\n", (unsigned int) relocation, (unsigned int) relocation, (int) relocation); \
 859     }
 860
 861 #define PRINT_DEBUG_RELOC_INFO_AFTER \
 862     { \
 863       ARC_DEBUG ("after  = 0x%08x\n", (unsigned int) insn); \
 864     }
 865
 866 #define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
 867   case R_##TYPE: \
 868     { \
 869       bfd_vma bitsize ATTRIBUTE_UNUSED = BITSIZE; \
 870       relocation = FORMULA  ; \
 871       PRINT_DEBUG_RELOC_INFO_BEFORE(FORMULA) \
 872       insn = RELOC_FUNCTION (insn, relocation); \
 873       PRINT_DEBUG_RELOC_INFO_AFTER \
 874     } \
 875     break;
 876
 877 static bfd_vma
 878 reverse_me (struct arc_relocation_data reloc_data, bfd_vma reloc)
 879 {
 880   if (reloc_data.input_section && reloc_data.input_section->flags & SEC_CODE)
 881     return ((0x0000fffff & reloc) << 16) | ((0xffff0000 & reloc) >> 16);
 882   else
 883     return reloc;
 884 }
 885
 886 static bfd_reloc_status_type
 887 arc_do_relocation (bfd_byte * contents,
 888                    struct arc_relocation_data reloc_data,
 889                    struct bfd_link_info *info)
 890 {
 891   bfd_vma relocation = 0;
 892   bfd_vma insn;
 893   bfd_vma orig_insn ATTRIBUTE_UNUSED;
 894   struct elf_link_hash_table *htab ATTRIBUTE_UNUSED = elf_hash_table (info);
 895
 896   if (reloc_data.should_relocate == FALSE)
 897     return bfd_reloc_ok;
 898
 899   switch (reloc_data.howto->size)
 900     {
 901       case 2:
 902         insn = arc_bfd_get_32 (reloc_data.input_section->owner,
 903                                contents + reloc_data.reloc_offset,
 904                                reloc_data.input_section);
 905         break;
 906       case 1:
 907       case 0:
 908         insn = arc_bfd_get_16 (reloc_data.input_section->owner,
 909                                contents + reloc_data.reloc_offset,
 910                                reloc_data.input_section);
 911         break;
 912       default:
 913         insn = 0;
 914         BFD_ASSERT (0);
 915         break;
 916     }
 917
 918   orig_insn = insn;
 919
 920   switch (reloc_data.howto->type)
 921     {
 922 #include "elf/arc-reloc.def"
 923
 924       default:
 925         BFD_ASSERT (0);
 926         break;
 927     }
 928
 929   /* Check for relocation overflow.  */
 930   if (reloc_data.howto->complain_on_overflow != complain_overflow_dont)
 931     {
 932       bfd_reloc_status_type flag;
 933       flag = bfd_check_overflow (reloc_data.howto->complain_on_overflow,
 934                                  reloc_data.howto->bitsize,
 935                                  reloc_data.howto->rightshift,
 936                                  bfd_arch_bits_per_address (reloc_data.input_section->owner),
 937                                  relocation);
 938
 939 #undef  DEBUG_ARC_RELOC
 940 #define DEBUG_ARC_RELOC(A) debug_arc_reloc (A)
 941       if (flag != bfd_reloc_ok)
 942         {
 943           PR_DEBUG ( "Relocation overflows !!!!\n");
 944
 945           DEBUG_ARC_RELOC (reloc_data);
 946
 947           PR_DEBUG (
 948                   "Relocation value = signed -> %d, unsigned -> %u"
 949                   ", hex -> (0x%08x)\n",
 950                   (int) relocation,
 951                   (unsigned int) relocation,
 952                   (unsigned int) relocation);
 953           return flag;
 954         }
 955     }
 956 #undef  DEBUG_ARC_RELOC
 957 #define DEBUG_ARC_RELOC(A)
 958
 959   switch (reloc_data.howto->size)
 960     {
 961       case 2:
 962         arc_bfd_put_32 (reloc_data.input_section->owner, insn,
 963                        contents + reloc_data.reloc_offset,
 964                        reloc_data.input_section);
 965         break;
 966       case 1:
 967       case 0:
 968         arc_bfd_put_16 (reloc_data.input_section->owner, insn,
 969                        contents + reloc_data.reloc_offset,
 970                        reloc_data.input_section);
 971         break;
 972       default:
 973         ARC_DEBUG ("size = %d\n", reloc_data.howto->size);
 974         BFD_ASSERT (0);
 975         break;
 976     }
 977
 978   return bfd_reloc_ok;
 979 }
 980 #undef S
 981 #undef A
 982 #undef B
 983 #undef G
 984 #undef GOT
 985 #undef L
 986 #undef MES
 987 #undef P
 988 #undef SECTSTAR
 989 #undef SECTSTART
 990 #undef _SDA_BASE_
 991 #undef none
 992
 993 #undef ARC_RELOC_HOWTO
 994
 995 static struct got_entry **
 996 arc_get_local_got_ents (bfd * abfd)
 997 {
 998   static struct got_entry **local_got_ents = NULL;
 999
1000   if (local_got_ents == NULL)
1001     {
1002       size_t       size;
1003       Elf_Internal_Shdr *symtab_hdr = &((elf_tdata (abfd))->symtab_hdr);
1004
1005       size = symtab_hdr->sh_info * sizeof (bfd_vma);
1006       local_got_ents = (struct got_entry **)
1007         bfd_alloc (abfd, sizeof(struct got_entry *) * size);
1008       if (local_got_ents == NULL)
1009         return FALSE;
1010
1011       memset (local_got_ents, 0, sizeof(struct got_entry *) * size);
1012       elf_local_got_ents (abfd) = local_got_ents;
1013     }
1014
1015   return local_got_ents;
1016 }
1017
1018 /* Relocate an arc ELF section.
1019    Function : elf_arc_relocate_section
1020    Brief    : Relocate an arc section, by handling all the relocations
1021              appearing in that section.
1022    Args     : output_bfd    : The bfd being written to.
1023               info          : Link information.
1024               input_bfd     : The input bfd.
1025               input_section : The section being relocated.
1026               contents      : contents of the section being relocated.
1027               relocs        : List of relocations in the section.
1028               local_syms    : is a pointer to the swapped in local symbols.
1029               local_section : is an array giving the section in the input file
1030                               corresponding to the st_shndx field of each
1031                               local symbol.  */
1032 static bfd_boolean
1033 elf_arc_relocate_section (bfd *            output_bfd,
1034                           struct bfd_link_info *  info,
1035                           bfd *            input_bfd,
1036                           asection *          input_section,
1037                           bfd_byte *          contents,
1038                           Elf_Internal_Rela *     relocs,
1039                           Elf_Internal_Sym *      local_syms,
1040                           asection **        local_sections)
1041 {
1042   Elf_Internal_Shdr *      symtab_hdr;
1043   struct elf_link_hash_entry ** sym_hashes;
1044   struct got_entry **      local_got_ents;
1045   Elf_Internal_Rela *      rel;
1046   Elf_Internal_Rela *      relend;
1047   struct elf_link_hash_table *htab = elf_hash_table (info);
1048
1049   symtab_hdr = &((elf_tdata (input_bfd))->symtab_hdr);
1050   sym_hashes = elf_sym_hashes (input_bfd);
1051
1052   rel = relocs;
1053   relend = relocs + input_section->reloc_count;
1054   for (; rel < relend; rel++)
1055     {
1056       enum elf_arc_reloc_type       r_type;
1057       reloc_howto_type *            howto;
1058       unsigned long              r_symndx;
1059       struct elf_link_hash_entry *  h;
1060       Elf_Internal_Sym *            sym;
1061       asection *                    sec;
1062       struct elf_link_hash_entry *h2;
1063
1064       struct arc_relocation_data reloc_data =
1065       {
1066         .reloc_offset = 0,
1067         .reloc_addend = 0,
1068         .got_offset_value = 0,
1069         .sym_value = 0,
1070         .sym_section = NULL,
1071         .howto = NULL,
1072         .input_section = NULL,
1073         .sdata_begin_symbol_vma = 0,
1074         .sdata_begin_symbol_vma_set = FALSE,
1075         .got_symbol_vma = 0,
1076         .should_relocate = FALSE
1077       };
1078
1079       r_type = ELF32_R_TYPE (rel->r_info);
1080
1081       if (r_type >= (int) R_ARC_max)
1082         {
1083           bfd_set_error (bfd_error_bad_value);
1084           return FALSE;
1085         }
1086       howto = &elf_arc_howto_table[r_type];
1087
1088       r_symndx = ELF32_R_SYM (rel->r_info);
1089
1090       /* If we are generating another .o file and the symbol in not
1091          local, skip this relocation.  */
1092       if (bfd_link_relocatable (info))
1093         {
1094           /* This is a relocateable link.  We don't have to change
1095              anything, unless the reloc is against a section symbol,
1096              in which case we have to adjust according to where the
1097              section symbol winds up in the output section.  */
1098
1099           /* Checks if this is a local symbol and thus the reloc
1100              might (will??) be against a section symbol.  */
1101           if (r_symndx < symtab_hdr->sh_info)
1102             {
1103               sym = local_syms + r_symndx;
1104               if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
1105                 {
1106                   sec = local_sections[r_symndx];
1107
1108                   /* for RELA relocs.Just adjust the addend
1109                      value in the relocation entry.  */
1110                   rel->r_addend += sec->output_offset + sym->st_value;
1111
1112                   BFD_DEBUG_PIC (
1113                     PR_DEBUG ("local symbols reloc "
1114                               "(section=%d %s) seen in %s\n",
1115                               r_symndx,
1116                               local_sections[r_symndx]->name,
1117                               __PRETTY_FUNCTION__)
1118                   );
1119                 }
1120             }
1121
1122           continue;
1123         }
1124
1125       h2 = elf_link_hash_lookup (elf_hash_table (info), "__SDATA_BEGIN__",
1126                                  FALSE, FALSE, TRUE);
1127
1128       if (reloc_data.sdata_begin_symbol_vma_set == FALSE
1129             && h2 != NULL && h2->root.type != bfd_link_hash_undefined
1130             && h2->root.u.def.section->output_section != NULL)
1131         /* TODO: Verify this condition.  */
1132         {
1133           reloc_data.sdata_begin_symbol_vma =
1134             (h2->root.u.def.value +
1135              h2->root.u.def.section->output_section->vma);
1136           reloc_data.sdata_begin_symbol_vma_set = TRUE;
1137         }
1138
1139       reloc_data.input_section = input_section;
1140       reloc_data.howto = howto;
1141       reloc_data.reloc_offset = rel->r_offset;
1142       reloc_data.reloc_addend = rel->r_addend;
1143
1144       /* This is a final link.  */
1145       h = NULL;
1146       sym = NULL;
1147       sec = NULL;
1148
1149       if (r_symndx < symtab_hdr->sh_info) /* A local symbol.  */
1150         {
1151           local_got_ents = arc_get_local_got_ents (output_bfd);
1152           struct got_entry *entry = local_got_ents[r_symndx];
1153
1154           sym = local_syms + r_symndx;
1155           sec = local_sections[r_symndx];
1156
1157           reloc_data.sym_value = sym->st_value;
1158           reloc_data.sym_section = sec;
1159
1160           if ((is_reloc_for_GOT (howto)
1161                || is_reloc_for_TLS (howto)) && entry != NULL)
1162             {
1163               if (is_reloc_for_TLS (howto))
1164                 while (entry->type == GOT_NORMAL && entry->next != NULL)
1165                   entry = entry->next;
1166
1167               if (is_reloc_for_GOT (howto))
1168                 while (entry->type != GOT_NORMAL && entry->next != NULL)
1169                   entry = entry->next;
1170
1171               if (entry->type == GOT_TLS_GD && entry->processed == FALSE)
1172                 {
1173                   bfd_vma sym_vma = sym->st_value
1174                                     + sec->output_section->vma
1175                                     + sec->output_offset;
1176
1177                   /* Create dynamic relocation for local sym.  */
1178                   ADD_RELA (output_bfd, got, entry->offset, 0,
1179                             R_ARC_TLS_DTPMOD, 0);
1180                   ADD_RELA (output_bfd, got, entry->offset+4, 0,
1181                             R_ARC_TLS_DTPOFF, 0);
1182
1183                   bfd_vma sec_vma = sec->output_section->vma
1184                                     + sec->output_offset;
1185                   bfd_put_32 (output_bfd, sym_vma - sec_vma,
1186                               htab->sgot->contents + entry->offset + 4);
1187
1188                   ARC_DEBUG ("arc_info: FIXED -> GOT_TLS_GD value "
1189                          "= 0x%x @ 0x%x, for symbol %s\n",
1190                          sym_vma - sec_vma,
1191                          htab->sgot->contents + entry->offset + 4,
1192                          "(local)");
1193
1194                   entry->processed = TRUE;
1195                 }
1196               if (entry->type == GOT_TLS_IE && entry->processed == FALSE)
1197                 {
1198                   bfd_vma sym_vma = sym->st_value
1199                                     + sec->output_section->vma
1200                                     + sec->output_offset;
1201                   bfd_vma sec_vma = htab->tls_sec->output_section->vma;
1202                   bfd_put_32 (output_bfd, sym_vma - sec_vma,
1203                               htab->sgot->contents + entry->offset);
1204                   /* TODO: Check if this type of relocs is the cause
1205                      for all the ARC_NONE dynamic relocs.  */
1206
1207                   ARC_DEBUG ("arc_info: FIXED -> GOT_TLS_IE value = "
1208                          "0x%x @ 0x%x, for symbol %s\n",
1209                          sym_vma - sec_vma,
1210                          htab->sgot->contents + entry->offset,
1211                          "(local)");
1212
1213                   entry->processed = TRUE;
1214                 }
1215               if (entry->type == GOT_NORMAL && entry->processed == FALSE)
1216                 {
1217                   bfd_vma sec_vma = reloc_data.sym_section->output_section->vma
1218                                     + reloc_data.sym_section->output_offset;
1219
1220                   bfd_put_32 (output_bfd, reloc_data.sym_value + sec_vma,
1221                               htab->sgot->contents + entry->offset);
1222
1223                   ARC_DEBUG ("arc_info: PATCHED: 0x%08x @ 0x%08x for "
1224                          "sym %s in got offset 0x%x\n",
1225                          reloc_data.sym_value + sec_vma,
1226                          htab->sgot->output_section->vma
1227                          + htab->sgot->output_offset + entry->offset,
1228                          "(local)",
1229                          entry->offset);
1230                   entry->processed = TRUE;
1231                 }
1232
1233               reloc_data.got_offset_value = entry->offset;
1234               ARC_DEBUG ("arc_info: GOT_ENTRY = %d, offset = 0x%x, "
1235                      "vma = 0x%x for symbol %s\n",
1236                      entry->type, entry->offset,
1237                      htab->sgot->output_section->vma
1238                      + htab->sgot->output_offset + entry->offset,
1239                      "(local)");
1240             }
1241
1242           BFD_ASSERT (htab->sgot != NULL || !is_reloc_for_GOT (howto));
1243           if (htab->sgot != NULL)
1244             reloc_data.got_symbol_vma = htab->sgot->output_section->vma
1245                                         + htab->sgot->output_offset;
1246
1247           reloc_data.should_relocate = TRUE;
1248         }
1249       else /* Global symbol.  */
1250         {
1251           /* Get the symbol's entry in the symtab.  */
1252           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1253
1254           while (h->root.type == bfd_link_hash_indirect
1255                  || h->root.type == bfd_link_hash_warning)
1256             h = (struct elf_link_hash_entry *) h->root.u.i.link;
1257
1258           BFD_ASSERT ((h->dynindx == -1) >= (h->forced_local != 0));
1259           /* If we have encountered a definition for this symbol.  */
1260           if (h->root.type == bfd_link_hash_defined
1261               || h->root.type == bfd_link_hash_defweak)
1262             {
1263               reloc_data.sym_value = h->root.u.def.value;
1264               reloc_data.sym_section = h->root.u.def.section;
1265
1266               reloc_data.should_relocate = TRUE;
1267
1268               if (is_reloc_for_GOT (howto) && !bfd_link_pic (info))
1269                 {
1270                   /* TODO: Change it to use arc_do_relocation with
1271                     ARC_32 reloc.  Try to use ADD_RELA macro.  */
1272                   bfd_vma relocation =
1273                     reloc_data.sym_value + reloc_data.reloc_addend
1274                     + (reloc_data.sym_section->output_section != NULL ?
1275                         (reloc_data.sym_section->output_offset
1276                          + reloc_data.sym_section->output_section->vma)
1277                       : 0);
1278
1279                   BFD_ASSERT (h->got.glist);
1280                   bfd_vma got_offset = h->got.glist->offset;
1281                   bfd_put_32 (output_bfd, relocation,
1282                               htab->sgot->contents + got_offset);
1283                 }
1284               if (is_reloc_for_PLT (howto) && h->plt.offset != (bfd_vma) -1)
1285                 {
1286                   /* TODO: This is repeated up here.  */
1287                   reloc_data.sym_value = h->plt.offset;
1288                   reloc_data.sym_section = htab->splt;
1289                 }
1290             }
1291           else if (h->root.type == bfd_link_hash_undefweak)
1292             {
1293               /* Is weak symbol and has no definition.  */
1294               if (is_reloc_for_GOT (howto))
1295                 {
1296                   reloc_data.sym_value = h->root.u.def.value;
1297                   reloc_data.sym_section = htab->sgot;
1298                   reloc_data.should_relocate = TRUE;
1299                 }
1300               else if (is_reloc_for_PLT (howto)
1301                        && h->plt.offset != (bfd_vma) -1)
1302                 {
1303                   /* TODO: This is repeated up here.  */
1304                   reloc_data.sym_value = h->plt.offset;
1305                   reloc_data.sym_section = htab->splt;
1306                   reloc_data.should_relocate = TRUE;
1307                 }
1308               else
1309                 continue;
1310             }
1311           else
1312             {
1313               if (is_reloc_for_GOT (howto))
1314                 {
1315                   reloc_data.sym_value = h->root.u.def.value;
1316                   reloc_data.sym_section = htab->sgot;
1317
1318                   reloc_data.should_relocate = TRUE;
1319                 }
1320               else if (is_reloc_for_PLT (howto))
1321                 {
1322                   reloc_data.sym_value = h->plt.offset;
1323                   reloc_data.sym_section = htab->splt;
1324
1325                   reloc_data.should_relocate = TRUE;
1326                 }
1327               else if (!(*info->callbacks->undefined_symbol)
1328                        (info, h->root.root.string, input_bfd, input_section,
1329                         rel->r_offset,!bfd_link_pic (info)))
1330                 {
1331                   return FALSE;
1332                 }
1333             }
1334
1335           if (h->got.glist != NULL)
1336             {
1337               struct got_entry *entry = h->got.glist;
1338
1339               if (is_reloc_for_GOT (howto) || is_reloc_for_TLS (howto))
1340                 {
1341                   if (! elf_hash_table (info)->dynamic_sections_created
1342                       || (bfd_link_pic (info)
1343                           && SYMBOL_REFERENCES_LOCAL (info, h)))
1344                     {
1345                       reloc_data.sym_value = h->root.u.def.value;
1346                       reloc_data.sym_section = h->root.u.def.section;
1347
1348                       if (is_reloc_for_TLS (howto))
1349                         while (entry->type == GOT_NORMAL && entry->next != NULL)
1350                           entry = entry->next;
1351
1352                       if (entry->processed == FALSE
1353                           && (entry->type == GOT_TLS_GD
1354                               || entry->type == GOT_TLS_IE))
1355                         {
1356                           bfd_vma sym_value = h->root.u.def.value
1357                             + h->root.u.def.section->output_section->vma
1358                             + h->root.u.def.section->output_offset;
1359
1360                           bfd_vma sec_vma =
1361                             elf_hash_table (info)->tls_sec->output_section->vma;
1362
1363                           bfd_put_32 (output_bfd,
1364                                       sym_value - sec_vma,
1365                                       htab->sgot->contents + entry->offset
1366                                       + (entry->existing_entries == MOD_AND_OFF ? 4 : 0));
1367
1368                           ARC_DEBUG ("arc_info: FIXED -> %s value = 0x%x "
1369                                      "@ 0x%x, for symbol %s\n",
1370                                      (entry->type == GOT_TLS_GD ? "GOT_TLS_GD" :
1371                                       "GOT_TLS_IE"),
1372                                      sym_value - sec_vma,
1373                                      htab->sgot->contents + entry->offset
1374                                      + (entry->existing_entries == MOD_AND_OFF ? 4 : 0),
1375                                      h->root.root.string);
1376
1377                           entry->processed = TRUE;
1378                         }
1379
1380                       if (entry->type == GOT_TLS_IE && entry->processed == FALSE)
1381                         {
1382                           bfd_vma sec_vma = htab->tls_sec->output_section->vma;
1383                           bfd_put_32 (output_bfd,
1384                                       reloc_data.sym_value - sec_vma,
1385                                       htab->sgot->contents + entry->offset);
1386                         }
1387
1388                       if (entry->type == GOT_NORMAL && entry->processed == FALSE)
1389                         {
1390                           bfd_vma sec_vma =
1391                             reloc_data.sym_section->output_section->vma
1392                             + reloc_data.sym_section->output_offset;
1393
1394                           if (h->root.type != bfd_link_hash_undefweak)
1395                             {
1396                               bfd_put_32 (output_bfd,
1397                                           reloc_data.sym_value + sec_vma,
1398                                           htab->sgot->contents + entry->offset);
1399
1400                               ARC_DEBUG ("arc_info: PATCHED: 0x%08x "
1401                                          "@ 0x%08x for sym %s in got offset 0x%x\n",
1402                                          reloc_data.sym_value + sec_vma,
1403                                          htab->sgot->output_section->vma
1404                                          + htab->sgot->output_offset + entry->offset,
1405                                          h->root.root.string,
1406                                          entry->offset);
1407                             }
1408                           else
1409                             {
1410                               ARC_DEBUG ("arc_info: PATCHED: NOT_PATCHED "
1411                                          "@ 0x%08x for sym %s in got offset 0x%x "
1412                                          "(is undefweak)\n",
1413                                          htab->sgot->output_section->vma
1414                                          + htab->sgot->output_offset + entry->offset,
1415                                          h->root.root.string,
1416                                          entry->offset);
1417                             }
1418
1419                           entry->processed = TRUE;
1420                         }
1421                     }
1422                 }
1423
1424               reloc_data.got_offset_value = entry->offset;
1425
1426               ARC_DEBUG ("arc_info: GOT_ENTRY = %d, offset = 0x%x, "
1427                          "vma = 0x%x for symbol %s\n",
1428                          entry->type, entry->offset,
1429                          htab->sgot->output_section->vma
1430                          + htab->sgot->output_offset + entry->offset,
1431                          h->root.root.string);
1432             }
1433
1434           BFD_ASSERT (htab->sgot != NULL || !is_reloc_for_GOT (howto));
1435           if (htab->sgot != NULL)
1436             reloc_data.got_symbol_vma = htab->sgot->output_section->vma
1437                                         + htab->sgot->output_offset;
1438         }
1439
1440       switch (r_type)
1441         {
1442           case R_ARC_32:
1443           case R_ARC_32_ME:
1444           case R_ARC_PC32:
1445           case R_ARC_32_PCREL:
1446             if (bfd_link_pic (info)
1447                 && ((r_type != R_ARC_PC32 && r_type != R_ARC_32_PCREL)
1448                     || (h != NULL
1449                         && h->dynindx != -1
1450                         && (!info->symbolic || !h->def_regular))))
1451               {
1452                 Elf_Internal_Rela outrel;
1453                 bfd_byte *loc;
1454                 bfd_boolean skip = FALSE;
1455                 bfd_boolean relocate = FALSE;
1456                 asection *sreloc = _bfd_elf_get_dynamic_reloc_section
1457                                  (input_bfd, input_section,
1458                                   /*RELA*/ TRUE);
1459
1460                 BFD_ASSERT (sreloc != NULL);
1461
1462                 outrel.r_offset = _bfd_elf_section_offset (output_bfd,
1463                                                            info,
1464                                                            input_section,
1465                                                            rel->r_offset);
1466                 if (outrel.r_offset == (bfd_vma) -1)
1467                   skip = TRUE;
1468
1469                 outrel.r_addend = rel->r_addend;
1470                 outrel.r_offset += (input_section->output_section->vma
1471                                     + input_section->output_offset);
1472
1473                 if (skip)
1474                   {
1475                     memset (&outrel, 0, sizeof outrel);
1476                     relocate = FALSE;
1477                   }
1478                 else if (r_type == R_ARC_PC32
1479                          || r_type == R_ARC_32_PCREL)
1480                   {
1481                     BFD_ASSERT (h != NULL && h->dynindx != -1);
1482                     if ((input_section->flags & SEC_ALLOC) != 0)
1483                       relocate = FALSE;
1484                     else
1485                       relocate = TRUE;
1486                     outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
1487                   }
1488                 else
1489                   {
1490                     /* Handle local symbols, they either do not have a
1491                        global hash table entry (h == NULL), or are
1492                        forced local due to a version script
1493                        (h->forced_local), or the third condition is
1494                        legacy, it appears to say something like, for
1495                        links where we are pre-binding the symbols, or
1496                        there's not an entry for this symbol in the
1497                        dynamic symbol table, and it's a regular symbol
1498                        not defined in a shared object, then treat the
1499                        symbol as local, resolve it now.  */
1500                     if (h == NULL
1501                         || ((info->symbolic || h->dynindx == -1)
1502                             && h->def_regular)
1503                         || h->forced_local)
1504                       {
1505                         relocate = TRUE;
1506                         /* outrel.r_addend = 0; */
1507                         outrel.r_info = ELF32_R_INFO (0, R_ARC_RELATIVE);
1508                       }
1509                     else
1510                       {
1511                         BFD_ASSERT (h->dynindx != -1);
1512                         if ((input_section->flags & SEC_ALLOC) != 0)
1513                           relocate = FALSE;
1514                         else
1515                           relocate = TRUE;
1516                         outrel.r_info = ELF32_R_INFO (h->dynindx, R_ARC_32);
1517                       }
1518                   }
1519
1520                 BFD_ASSERT (sreloc->contents != 0);
1521
1522                 loc = sreloc->contents;
1523                 loc += sreloc->reloc_count * sizeof (Elf32_External_Rela);
1524                 sreloc->reloc_count += 1;
1525
1526                 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
1527
1528                 if (relocate == FALSE)
1529                   continue;
1530               }
1531             break;
1532           default:
1533             break;
1534         }
1535
1536       if (is_reloc_SDA_relative (howto)
1537           && (reloc_data.sdata_begin_symbol_vma_set == FALSE))
1538         {
1539           (*_bfd_error_handler)
1540               ("Error: Linker symbol __SDATA_BEGIN__ not found");
1541           bfd_set_error (bfd_error_bad_value);
1542           return FALSE;
1543         }
1544
1545       DEBUG_ARC_RELOC (reloc_data);
1546
1547       if (arc_do_relocation (contents, reloc_data, info) != bfd_reloc_ok)
1548         return FALSE;
1549     }
1550
1551   return TRUE;
1552 }
1553
1554 static struct dynamic_sections
1555 arc_create_dynamic_sections (bfd * abfd, struct bfd_link_info *info)
1556 {
1557   struct elf_link_hash_table *htab;
1558   bfd    *dynobj;
1559   struct dynamic_sections ds =
1560     {
1561       .initialized = FALSE,
1562       .sgot = NULL,
1563       .srelgot = NULL,
1564       .sgotplt = NULL,
1565       .srelgotplt = NULL,
1566       .sdyn = NULL,
1567       .splt = NULL,
1568       .srelplt = NULL
1569     };
1570
1571   htab = elf_hash_table (info);
1572   BFD_ASSERT (htab);
1573
1574   /* Create dynamic sections for relocatable executables so that we
1575      can copy relocations.  */
1576   if (! htab->dynamic_sections_created && bfd_link_pic (info))
1577     {
1578       if (! _bfd_elf_link_create_dynamic_sections (abfd, info))
1579         BFD_ASSERT (0);
1580     }
1581
1582   dynobj = (elf_hash_table (info))->dynobj;
1583
1584   if (dynobj)
1585     {
1586       ds.sgot = htab->sgot;
1587       ds.srelgot = htab->srelgot;
1588
1589       ds.sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
1590       ds.srelgotplt = ds.srelplt;
1591
1592       ds.splt = bfd_get_section_by_name (dynobj, ".plt");
1593       ds.srelplt = bfd_get_section_by_name (dynobj, ".rela.plt");
1594     }
1595
1596   if (htab->dynamic_sections_created)
1597     {
1598       ds.sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
1599     }
1600
1601   ds.initialized = TRUE;
1602
1603   return ds;
1604 }
1605
1606 #define ADD_SYMBOL_REF_SEC_AND_RELOC(SECNAME, COND_FOR_RELOC, H)        \
1607   htab->s##SECNAME->size;                                               \
1608   {                                                                     \
1609     if (COND_FOR_RELOC)                                                 \
1610       {                                                                 \
1611         htab->srel##SECNAME->size += sizeof (Elf32_External_Rela);      \
1612           ARC_DEBUG ("arc_info: Added reloc space in "                  \
1613                      #SECNAME " section at " __FILE__                   \
1614                      ":%d for symbol\n",                                \
1615                      __LINE__, name_for_global_symbol (H));             \
1616       }                                                                 \
1617     if (H)                                                              \
1618       if (h->dynindx == -1 && !h->forced_local)                         \
1619         if (! bfd_elf_link_record_dynamic_symbol (info, H))             \
1620           return FALSE;                                                 \
1621      htab->s##SECNAME->size += 4;                       \
1622    }
1623
1624 static bfd_boolean
1625 elf_arc_check_relocs (bfd *                      abfd,
1626                       struct bfd_link_info *     info,
1627                       asection *                 sec,
1628                       const Elf_Internal_Rela *  relocs)
1629 {
1630   Elf_Internal_Shdr *           symtab_hdr;
1631   struct elf_link_hash_entry ** sym_hashes;
1632   struct got_entry **           local_got_ents;
1633   const Elf_Internal_Rela *     rel;
1634   const Elf_Internal_Rela *     rel_end;
1635   bfd *                         dynobj;
1636   asection *                    sreloc = NULL;
1637   struct elf_link_hash_table *  htab = elf_hash_table (info);
1638
1639   if (bfd_link_relocatable (info))
1640     return TRUE;
1641
1642   dynobj = (elf_hash_table (info))->dynobj;
1643   symtab_hdr = &((elf_tdata (abfd))->symtab_hdr);
1644   sym_hashes = elf_sym_hashes (abfd);
1645   local_got_ents = arc_get_local_got_ents (abfd);
1646
1647   rel_end = relocs + sec->reloc_count;
1648   for (rel = relocs; rel < rel_end; rel++)
1649     {
1650       enum elf_arc_reloc_type r_type;
1651       reloc_howto_type *howto;
1652       unsigned long   r_symndx;
1653       struct elf_link_hash_entry *h;
1654
1655       r_type = ELF32_R_TYPE (rel->r_info);
1656
1657       if (r_type >= (int) R_ARC_max)
1658         {
1659           bfd_set_error (bfd_error_bad_value);
1660           return FALSE;
1661         }
1662       howto = &elf_arc_howto_table[r_type];
1663
1664       if (dynobj == NULL
1665           && (is_reloc_for_GOT (howto) == TRUE
1666               || is_reloc_for_TLS (howto) == TRUE))
1667         {
1668           dynobj = elf_hash_table (info)->dynobj = abfd;
1669           if (! _bfd_elf_create_got_section (abfd, info))
1670             return FALSE;
1671         }
1672
1673       /* Load symbol information.  */
1674       r_symndx = ELF32_R_SYM (rel->r_info);
1675       if (r_symndx < symtab_hdr->sh_info) /* Is a local symbol.  */
1676         h = NULL;
1677       else /* Global one.  */
1678         h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1679
1680       switch (r_type)
1681         {
1682           case R_ARC_32:
1683           case R_ARC_32_ME:
1684             /* During shared library creation, these relocs should not
1685                appear in a shared library (as memory will be read only
1686                and the dynamic linker can not resolve these.  However
1687                the error should not occur for e.g. debugging or
1688                non-readonly sections.  */
1689             if (bfd_link_dll (info) && !bfd_link_pie (info)
1690                 && (sec->flags & SEC_ALLOC) != 0
1691                 && (sec->flags & SEC_READONLY) != 0)
1692               {
1693                 const char *name;
1694                 if (h)
1695                   name = h->root.root.string;
1696                 else
1697                   /* bfd_elf_sym_name (abfd, symtab_hdr, isym, NULL);  */
1698                   name = "UNKNOWN";
1699                 (*_bfd_error_handler)
1700                   (_("\
1701 %B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
1702                     abfd,
1703                     arc_elf_howto (r_type)->name,
1704                     name);
1705                 bfd_set_error (bfd_error_bad_value);
1706                 return FALSE;
1707               }
1708
1709             /* In some cases we are not setting the 'non_got_ref'
1710                flag, even though the relocations don't require a GOT
1711                access.  We should extend the testing in this area to
1712                ensure that no significant cases are being missed.  */
1713             if (h)
1714               h->non_got_ref = 1;
1715             /* FALLTHROUGH */
1716           case R_ARC_PC32:
1717           case R_ARC_32_PCREL:
1718             if (bfd_link_pic (info)
1719                 && ((r_type != R_ARC_PC32 && r_type != R_ARC_32_PCREL)
1720                     || (h != NULL
1721                         && h->dynindx != -1
1722                         && (!info->symbolic || !h->def_regular))))
1723               {
1724                 if (sreloc == NULL)
1725                   {
1726                     sreloc = _bfd_elf_make_dynamic_reloc_section (sec, dynobj,
1727                                                                   2, abfd,
1728                                                                   /*rela*/
1729                                                                   TRUE);
1730
1731                     if (sreloc == NULL)
1732                       return FALSE;
1733                   }
1734                 sreloc->size += sizeof (Elf32_External_Rela);
1735
1736               }
1737           default:
1738             break;
1739         }
1740
1741       if (is_reloc_for_PLT (howto) == TRUE)
1742         {
1743           if (h == NULL)
1744             continue;
1745           else
1746             h->needs_plt = 1;
1747         }
1748
1749       if (is_reloc_for_GOT (howto) == TRUE)
1750         {
1751           if (h == NULL)
1752             {
1753               /* Local symbol.  */
1754               if (local_got_ents[r_symndx] == NULL)
1755                 {
1756                   bfd_vma offset =
1757                     ADD_SYMBOL_REF_SEC_AND_RELOC (got,
1758                                                   bfd_link_pic (info),
1759                                                   NULL);
1760                   new_got_entry_to_list (&(local_got_ents[r_symndx]),
1761                                          GOT_NORMAL, offset, NONE);
1762                 }
1763             }
1764           else
1765             {
1766               /* Global symbol.  */
1767               h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1768               if (h->got.glist == NULL)
1769                 {
1770                   bfd_vma offset =
1771                     ADD_SYMBOL_REF_SEC_AND_RELOC (got, TRUE, h);
1772                   new_got_entry_to_list (&h->got.glist,
1773                                          GOT_NORMAL, offset, NONE);
1774                 }
1775             }
1776         }
1777
1778       if (is_reloc_for_TLS (howto) == TRUE)
1779         {
1780           enum tls_type_e type = GOT_UNKNOWN;
1781
1782           switch (r_type)
1783             {
1784               case R_ARC_TLS_GD_GOT:
1785                 type = GOT_TLS_GD;
1786                 break;
1787               case R_ARC_TLS_IE_GOT:
1788                 type = GOT_TLS_IE;
1789                 break;
1790               default:
1791                 break;
1792             }
1793
1794           struct got_entry **list = NULL;
1795           if (h != NULL)
1796             list = &(h->got.glist);
1797           else
1798             list = &(local_got_ents[r_symndx]);
1799
1800           if (type != GOT_UNKNOWN && !symbol_has_entry_of_type (*list, type))
1801             {
1802               enum tls_got_entries entries = NONE;
1803               bfd_vma offset =
1804                 ADD_SYMBOL_REF_SEC_AND_RELOC (got, TRUE, h);
1805
1806               if (type == GOT_TLS_GD)
1807                 {
1808                   bfd_vma ATTRIBUTE_UNUSED notneeded =
1809                     ADD_SYMBOL_REF_SEC_AND_RELOC (got, TRUE, h);
1810                   entries = MOD_AND_OFF;
1811                 }
1812
1813               if (entries == NONE)
1814                 entries = OFF;
1815
1816               new_got_entry_to_list (list, type, offset, entries);
1817             }
1818         }
1819     }
1820
1821   return TRUE;
1822 }
1823
1824 #define ELF_DYNAMIC_INTERPRETER  "/sbin/ld-uClibc.so"
1825
1826 static struct plt_version_t *
1827 arc_get_plt_version (struct bfd_link_info *info)
1828 {
1829   int i;
1830
1831   for (i = 0; i < 1; i++)
1832     {
1833       ARC_DEBUG ("%d: size1 = %d, size2 = %d\n", i,
1834                  plt_versions[i].entry_size,
1835                  plt_versions[i].elem_size);
1836     }
1837
1838   if (bfd_get_mach (info->output_bfd) == bfd_mach_arc_arcv2)
1839     {
1840       if (bfd_link_pic (info))
1841         return &(plt_versions[ELF_ARCV2_PIC]);
1842       else
1843         return &(plt_versions[ELF_ARCV2_ABS]);
1844     }
1845   else
1846     {
1847       if (bfd_link_pic (info))
1848         return &(plt_versions[ELF_ARC_PIC]);
1849       else
1850         return &(plt_versions[ELF_ARC_ABS]);
1851     }
1852 }
1853
1854 static bfd_vma
1855 add_symbol_to_plt (struct bfd_link_info *info)
1856 {
1857   struct elf_link_hash_table *htab = elf_hash_table (info);
1858   bfd_vma ret;
1859
1860   struct plt_version_t *plt_data = arc_get_plt_version (info);
1861
1862   /* If this is the first .plt entry, make room for the special first
1863      entry.  */
1864   if (htab->splt->size == 0)
1865     htab->splt->size += plt_data->entry_size;
1866
1867   ret = htab->splt->size;
1868
1869   htab->splt->size += plt_data->elem_size;
1870   ARC_DEBUG ("PLT_SIZE = %d\n", htab->splt->size);
1871
1872   htab->sgotplt->size += 4;
1873   htab->srelplt->size += sizeof (Elf32_External_Rela);
1874
1875   return ret;
1876 }
1877
1878 #define PLT_DO_RELOCS_FOR_ENTRY(ABFD, DS, RELOCS)       \
1879   plt_do_relocs_for_symbol (ABFD, DS, RELOCS, 0, 0)
1880
1881 static void
1882 plt_do_relocs_for_symbol (bfd *abfd,
1883                           struct elf_link_hash_table *htab,
1884                           const struct plt_reloc *reloc,
1885                           bfd_vma plt_offset,
1886                           bfd_vma symbol_got_offset)
1887 {
1888   while (SYM_ONLY (reloc->symbol) != LAST_RELOC)
1889     {
1890       bfd_vma relocation = 0;
1891
1892       switch (SYM_ONLY (reloc->symbol))
1893         {
1894           case SGOT:
1895                 relocation =
1896                     htab->sgotplt->output_section->vma +
1897                     htab->sgotplt->output_offset + symbol_got_offset;
1898                 break;
1899         }
1900       relocation += reloc->addend;
1901
1902       if (IS_RELATIVE (reloc->symbol))
1903         {
1904           bfd_vma reloc_offset = reloc->offset;
1905           reloc_offset -= (IS_INSN_32 (reloc->symbol)) ? 4 : 0;
1906           reloc_offset -= (IS_INSN_24 (reloc->symbol)) ? 2 : 0;
1907
1908           relocation -= htab->splt->output_section->vma
1909                          + htab->splt->output_offset
1910                          + plt_offset + reloc_offset;
1911         }
1912
1913       /* TODO: being ME is not a property of the relocation but of the
1914          section of which is applying the relocation. */
1915       if (IS_MIDDLE_ENDIAN (reloc->symbol) || bfd_big_endian (abfd))
1916         {
1917           relocation =
1918               ((relocation & 0xffff0000) >> 16) |
1919               ((relocation & 0xffff) << 16);
1920         }
1921
1922       switch (reloc->size)
1923         {
1924           case 32:
1925             bfd_put_32 (htab->splt->output_section->owner,
1926                         relocation,
1927                         htab->splt->contents + plt_offset + reloc->offset);
1928             break;
1929         }
1930
1931       reloc = &(reloc[1]); /* Jump to next relocation.  */
1932     }
1933 }
1934
1935 static void
1936 relocate_plt_for_symbol (bfd *output_bfd,
1937                          struct bfd_link_info *info,
1938                          struct elf_link_hash_entry *h)
1939 {
1940   struct plt_version_t *plt_data = arc_get_plt_version (info);
1941   struct elf_link_hash_table *htab = elf_hash_table (info);
1942
1943   bfd_vma plt_index = (h->plt.offset  - plt_data->entry_size)
1944                       / plt_data->elem_size;
1945   bfd_vma got_offset = (plt_index + 3) * 4;
1946
1947   ARC_DEBUG ("arc_info: PLT_OFFSET = 0x%x, PLT_ENTRY_VMA = 0x%x, \
1948 GOT_ENTRY_OFFSET = 0x%x, GOT_ENTRY_VMA = 0x%x, for symbol %s\n",
1949              h->plt.offset,
1950              htab->splt->output_section->vma
1951              + htab->splt->output_offset
1952              + h->plt.offset,
1953              got_offset,
1954              htab->sgotplt->output_section->vma
1955              + htab->sgotplt->output_offset
1956              + got_offset,
1957              h->root.root.string);
1958
1959   memcpy (htab->splt->contents + h->plt.offset,
1960           plt_data->elem,
1961           plt_data->elem_size);
1962   plt_do_relocs_for_symbol (output_bfd, htab,
1963                             plt_data->elem_relocs,
1964                             h->plt.offset,
1965                             got_offset);
1966
1967   /* Fill in the entry in the global offset table.  */
1968   bfd_put_32 (output_bfd,
1969               (bfd_vma) (htab->splt->output_section->vma
1970                          + htab->splt->output_offset),
1971               htab->sgotplt->contents + got_offset);
1972
1973   /* TODO: Fill in the entry in the .rela.plt section.  */
1974   {
1975     Elf_Internal_Rela rel;
1976     bfd_byte *loc;
1977
1978     rel.r_offset = (htab->sgotplt->output_section->vma
1979                     + htab->sgotplt->output_offset
1980                     + got_offset);
1981     rel.r_addend = 0;
1982     rel.r_info = ELF32_R_INFO (h->dynindx, R_ARC_JMP_SLOT);
1983
1984     loc = htab->srelplt->contents;
1985     loc += plt_index * sizeof (Elf32_External_Rela); /* relA */
1986     bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
1987   }
1988 }
1989
1990 static void
1991 relocate_plt_for_entry (bfd *abfd,
1992                         struct bfd_link_info *info)
1993 {
1994   struct plt_version_t *plt_data = arc_get_plt_version (info);
1995   struct elf_link_hash_table *htab = elf_hash_table (info);
1996
1997   memcpy (htab->splt->contents, plt_data->entry,
1998           plt_data->entry_size);
1999   PLT_DO_RELOCS_FOR_ENTRY (abfd, htab, plt_data->entry_relocs);
2000 }
2001
2002 /* Desc : Adjust a symbol defined by a dynamic object and referenced
2003    by a regular object.  The current definition is in some section of
2004    the dynamic object, but we're not including those sections.  We
2005    have to change the definition to something the rest of the link can
2006    understand.  */
2007
2008 static bfd_boolean
2009 elf_arc_adjust_dynamic_symbol (struct bfd_link_info *info,
2010                               struct elf_link_hash_entry *h)
2011 {
2012   asection *s;
2013   unsigned int power_of_two;
2014   bfd *dynobj = (elf_hash_table (info))->dynobj;
2015   struct elf_link_hash_table *htab = elf_hash_table (info);
2016
2017   if (h->type == STT_FUNC
2018       || h->type == STT_GNU_IFUNC
2019       || h->needs_plt == 1)
2020     {
2021       if (!bfd_link_pic (info) && !h->def_dynamic && !h->ref_dynamic)
2022         {
2023           /* This case can occur if we saw a PLT32 reloc in an input
2024              file, but the symbol was never referred to by a dynamic
2025              object.  In such a case, we don't actually need to build
2026              a procedure linkage table, and we can just do a PC32
2027              reloc instead.  */
2028           BFD_ASSERT (h->needs_plt);
2029           return TRUE;
2030         }
2031
2032       /* Make sure this symbol is output as a dynamic symbol.  */
2033       if (h->dynindx == -1 && !h->forced_local
2034           && !bfd_elf_link_record_dynamic_symbol (info, h))
2035         return FALSE;
2036
2037       if (bfd_link_pic (info)
2038           || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h))
2039         {
2040           bfd_vma loc = add_symbol_to_plt (info);
2041
2042           if (!bfd_link_pic (info) && !h->def_regular)
2043             {
2044               h->root.u.def.section = htab->splt;
2045               h->root.u.def.value = loc;
2046             }
2047           h->plt.offset = loc;
2048         }
2049       else
2050         {
2051           h->plt.offset = (bfd_vma) -1;
2052           h->needs_plt = 0;
2053         }
2054       return TRUE;
2055     }
2056
2057   /* If this is a weak symbol, and there is a real definition, the
2058      processor independent code will have arranged for us to see the
2059      real definition first, and we can just use the same value.  */
2060   if (h->u.weakdef != NULL)
2061     {
2062       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
2063                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
2064       h->root.u.def.section = h->u.weakdef->root.u.def.section;
2065       h->root.u.def.value = h->u.weakdef->root.u.def.value;
2066       return TRUE;
2067     }
2068
2069   /* If there are no non-GOT references, we do not need a copy
2070      relocation.  */
2071   if (!h->non_got_ref)
2072     return TRUE;
2073
2074   /* This is a reference to a symbol defined by a dynamic object which
2075      is not a function.  */
2076
2077   /* If we are creating a shared library, we must presume that the
2078      only references to the symbol are via the global offset table.
2079      For such cases we need not do anything here; the relocations will
2080      be handled correctly by relocate_section.  */
2081   if (bfd_link_pic (info))
2082     return TRUE;
2083
2084   /* We must allocate the symbol in our .dynbss section, which will
2085      become part of the .bss section of the executable.  There will be
2086      an entry for this symbol in the .dynsym section.  The dynamic
2087      object will contain position independent code, so all references
2088      from the dynamic object to this symbol will go through the global
2089      offset table.  The dynamic linker will use the .dynsym entry to
2090      determine the address it must put in the global offset table, so
2091      both the dynamic object and the regular object will refer to the
2092      same memory location for the variable.  */
2093
2094   s = bfd_get_section_by_name (dynobj, ".dynbss");
2095   BFD_ASSERT (s != NULL);
2096
2097   /* We must generate a R_ARC_COPY reloc to tell the dynamic linker to
2098      copy the initial value out of the dynamic object and into the
2099      runtime process image.  We need to remember the offset into the
2100      .rela.bss section we are going to use.  */
2101   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
2102     {
2103       asection *srel;
2104
2105       srel = bfd_get_section_by_name (dynobj, ".rela.bss");
2106       BFD_ASSERT (srel != NULL);
2107       srel->size += sizeof (Elf32_External_Rela);
2108       h->needs_copy = 1;
2109     }
2110
2111   /* We need to figure out the alignment required for this symbol.  I
2112      have no idea how ELF linkers handle this.  */
2113   power_of_two = bfd_log2 (h->size);
2114   if (power_of_two > 3)
2115     power_of_two = 3;
2116
2117   /* Apply the required alignment.  */
2118   s->size = BFD_ALIGN (s->size, (bfd_size_type) (1 << power_of_two));
2119   if (power_of_two > bfd_get_section_alignment (dynobj, s))
2120     {
2121       if (! bfd_set_section_alignment (dynobj, s, power_of_two))
2122         return FALSE;
2123     }
2124
2125   /* Define the symbol as being at this point in the section.  */
2126   h->root.u.def.section = s;
2127   h->root.u.def.value = s->size;
2128
2129   /* Increment the section size to make room for the symbol.  */
2130   s->size += h->size;
2131
2132   return TRUE;
2133 }
2134
2135 /* Function :  elf_arc_finish_dynamic_symbol
2136    Brief    :  Finish up dynamic symbol handling.  We set the
2137              contents of various dynamic sections here.
2138    Args     :  output_bfd :
2139                info       :
2140                h          :
2141                sym        :
2142    Returns  : True/False as the return status.  */
2143
2144 static bfd_boolean
2145 elf_arc_finish_dynamic_symbol (bfd * output_bfd,
2146                                struct bfd_link_info *info,
2147                                struct elf_link_hash_entry *h,
2148                                Elf_Internal_Sym * sym)
2149 {
2150   if (h->plt.offset != (bfd_vma) -1)
2151     {
2152       relocate_plt_for_symbol (output_bfd, info, h);
2153
2154       if (!h->def_regular)
2155         {
2156           /* Mark the symbol as undefined, rather than as defined in
2157              the .plt section.  Leave the value alone.  */
2158           sym->st_shndx = SHN_UNDEF;
2159         }
2160     }
2161
2162   if (h->got.glist != NULL)
2163     {
2164       struct got_entry *list = h->got.glist;
2165
2166       /* Traverse the list of got entries for this symbol.  */
2167       while (list)
2168         {
2169           bfd_vma got_offset = h->got.glist->offset;
2170
2171           if (list->type == GOT_NORMAL
2172               && list->created_dyn_relocation == FALSE)
2173             {
2174               if (bfd_link_pic (info)
2175                   && (info->symbolic || h->dynindx == -1)
2176                   && h->def_regular)
2177                 {
2178                   ADD_RELA (output_bfd, got, got_offset, 0, R_ARC_RELATIVE, 0);
2179                 }
2180               else
2181                 {
2182                   ADD_RELA (output_bfd, got, got_offset, h->dynindx,
2183                           R_ARC_GLOB_DAT, 0);
2184                 }
2185               list->created_dyn_relocation = TRUE;
2186             }
2187           else if (list->existing_entries != NONE)
2188             {
2189               struct elf_link_hash_table *htab = elf_hash_table (info);
2190               enum tls_got_entries e = list->existing_entries;
2191
2192               BFD_ASSERT (list->type != GOT_TLS_GD
2193                           || list->existing_entries == MOD_AND_OFF);
2194
2195               bfd_vma index = h->dynindx == -1 ? 0 : h->dynindx;
2196               if (e == MOD_AND_OFF || e == MOD)
2197                 {
2198                   ADD_RELA (output_bfd, got, got_offset, index,
2199                             R_ARC_TLS_DTPMOD, 0);
2200                   ARC_DEBUG ("arc_info: TLS_DYNRELOC: type = %d, \
2201 GOT_OFFSET = 0x%x, GOT_VMA = 0x%x, INDEX = %d, ADDEND = 0x%x\n",
2202                              list->type,
2203                              got_offset,
2204                              htab->sgot->output_section->vma
2205                              + htab->sgot->output_offset + got_offset,
2206                              index, 0);
2207                 }
2208               if (e == MOD_AND_OFF || e == OFF)
2209                 {
2210                   bfd_vma addend = 0;
2211                   if (list->type == GOT_TLS_IE)
2212                     addend = bfd_get_32 (output_bfd,
2213                                          htab->sgot->contents + got_offset);
2214
2215                   ADD_RELA (output_bfd, got,
2216                             got_offset + (e == MOD_AND_OFF ? 4 : 0),
2217                             index,
2218                             (list->type == GOT_TLS_IE ?
2219                              R_ARC_TLS_TPOFF : R_ARC_TLS_DTPOFF),
2220                             addend);
2221
2222                   ARC_DEBUG ("arc_info: TLS_DYNRELOC: type = %d, \
2223 GOT_OFFSET = 0x%x, GOT_VMA = 0x%x, INDEX = %d, ADDEND = 0x%x\n",
2224                              list->type,
2225                              got_offset,
2226                              htab->sgot->output_section->vma
2227                              + htab->sgot->output_offset + got_offset,
2228                              index, addend);
2229                 }
2230             }
2231
2232           list = list->next;
2233         }
2234
2235       h->got.glist = NULL;
2236     }
2237
2238   if (h->needs_copy)
2239     {
2240       bfd_vma rel_offset = (h->root.u.def.value
2241                             + h->root.u.def.section->output_section->vma
2242                             + h->root.u.def.section->output_offset);
2243
2244       asection *srelbss =
2245         bfd_get_section_by_name (h->root.u.def.section->owner,
2246                                  ".rela.bss");
2247
2248       bfd_vma loc = (bfd_vma) srelbss->contents
2249                     + (srelbss->reloc_count * sizeof (Elf32_External_Rela));
2250       srelbss->reloc_count++;
2251
2252       Elf_Internal_Rela rel;
2253       rel.r_addend = 0;
2254       rel.r_offset = rel_offset;
2255       rel.r_info = ELF32_R_INFO (h->dynindx, R_ARC_COPY);
2256
2257       bfd_elf32_swap_reloca_out (output_bfd, &rel, (bfd_byte *) loc);
2258     }
2259
2260   /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute.  */
2261   if (strcmp (h->root.root.string, "_DYNAMIC") == 0
2262       || strcmp (h->root.root.string, "__DYNAMIC") == 0
2263       || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
2264     sym->st_shndx = SHN_ABS;
2265
2266   return TRUE;
2267 }
2268
2269 #define GET_SYMBOL_OR_SECTION(TAG, SYMBOL, SECTION, ASSERT)     \
2270   case TAG:                                                     \
2271   if (SYMBOL != NULL)                                           \
2272     {                                                           \
2273       h = elf_link_hash_lookup (elf_hash_table (info),          \
2274                                 SYMBOL, FALSE, FALSE, TRUE);    \
2275     }                                                           \
2276   else if (SECTION != NULL)                                     \
2277     {                                                           \
2278       s = bfd_get_section_by_name (output_bfd, SECTION);        \
2279       BFD_ASSERT (s != NULL || !ASSERT);                        \
2280       do_it = TRUE;                                             \
2281     }                                                           \
2282   break;
2283
2284 /* Function :  elf_arc_finish_dynamic_sections
2285    Brief    :  Finish up the dynamic sections handling.
2286    Args     :  output_bfd :
2287                info       :
2288                h          :
2289                sym        :
2290    Returns  : True/False as the return status.  */
2291
2292 static bfd_boolean
2293 elf_arc_finish_dynamic_sections (bfd * output_bfd,
2294                                  struct bfd_link_info *info)
2295 {
2296   struct dynamic_sections ds = arc_create_dynamic_sections (output_bfd, info);
2297   struct elf_link_hash_table *htab = elf_hash_table (info);
2298   bfd *dynobj = (elf_hash_table (info))->dynobj;
2299
2300   if (ds.sdyn)
2301     {
2302       Elf32_External_Dyn *dyncon, *dynconend;
2303
2304       dyncon = (Elf32_External_Dyn *) ds.sdyn->contents;
2305       dynconend =
2306         (Elf32_External_Dyn *) (ds.sdyn->contents + ds.sdyn->size);
2307       for (; dyncon < dynconend; dyncon++)
2308         {
2309           Elf_Internal_Dyn internal_dyn;
2310           bfd_boolean     do_it = FALSE;
2311
2312           struct elf_link_hash_entry *h = NULL;
2313           asection       *s = NULL;
2314
2315           bfd_elf32_swap_dyn_in (dynobj, dyncon, &internal_dyn);
2316
2317           switch (internal_dyn.d_tag)
2318             {
2319               GET_SYMBOL_OR_SECTION (DT_INIT, "_init", NULL, TRUE)
2320               GET_SYMBOL_OR_SECTION (DT_FINI, "_fini", NULL, TRUE)
2321               GET_SYMBOL_OR_SECTION (DT_PLTGOT, NULL, ".plt", TRUE)
2322               GET_SYMBOL_OR_SECTION (DT_JMPREL, NULL, ".rela.plt", TRUE)
2323               GET_SYMBOL_OR_SECTION (DT_PLTRELSZ, NULL, ".rela.plt", TRUE)
2324               GET_SYMBOL_OR_SECTION (DT_RELASZ, NULL, ".rela.plt", FALSE)
2325               GET_SYMBOL_OR_SECTION (DT_VERSYM, NULL, ".gnu.version", TRUE)
2326               GET_SYMBOL_OR_SECTION (DT_VERDEF, NULL, ".gnu.version_d", TRUE)
2327               GET_SYMBOL_OR_SECTION (DT_VERNEED, NULL, ".gnu.version_r", TRUE)
2328               default:
2329                 break;
2330             }
2331
2332           /* In case the dynamic symbols should be updated with a symbol.  */
2333           if (h != NULL
2334               && (h->root.type == bfd_link_hash_defined
2335                   || h->root.type == bfd_link_hash_defweak))
2336             {
2337               asection       *asec_ptr;
2338
2339               internal_dyn.d_un.d_val = h->root.u.def.value;
2340               asec_ptr = h->root.u.def.section;
2341               if (asec_ptr->output_section != NULL)
2342                 {
2343                   internal_dyn.d_un.d_val +=
2344                     (asec_ptr->output_section->vma +
2345                      asec_ptr->output_offset);
2346                 }
2347               else
2348                 {
2349                   /* The symbol is imported from another shared
2350                      library and does not apply to this one.  */
2351                   internal_dyn.d_un.d_val = 0;
2352                 }
2353               do_it = TRUE;
2354             }
2355           else if (s != NULL) /* With a section information.  */
2356             {
2357               switch (internal_dyn.d_tag)
2358                 {
2359                   case DT_PLTGOT:
2360                   case DT_JMPREL:
2361                   case DT_VERSYM:
2362                   case DT_VERDEF:
2363                   case DT_VERNEED:
2364                     internal_dyn.d_un.d_ptr = s->vma;
2365                     do_it = TRUE;
2366                     break;
2367
2368                   case DT_PLTRELSZ:
2369                     internal_dyn.d_un.d_val = s->size;
2370                     do_it = TRUE;
2371                     break;
2372
2373                   case DT_RELASZ:
2374                     if (s != NULL)
2375                       internal_dyn.d_un.d_val -= s->size;
2376                     do_it = TRUE;
2377                     break;
2378
2379                   default:
2380                     break;
2381                 }
2382             }
2383
2384           if (do_it == TRUE)
2385             bfd_elf32_swap_dyn_out (output_bfd, &internal_dyn, dyncon);
2386         }
2387
2388       if (htab->splt->size > 0)
2389         {
2390           relocate_plt_for_entry (output_bfd, info);
2391         }
2392
2393       /* TODO: Validate this.  */
2394       elf_section_data (htab->srelplt->output_section)->this_hdr.sh_entsize
2395         = 0xc;
2396     }
2397
2398   /* Fill in the first three entries in the global offset table.  */
2399   if (htab->sgot)
2400     {
2401       if (htab->sgot->size > 0 || htab->sgotplt->size > 0)
2402         {
2403           if (ds.sdyn == NULL)
2404             bfd_put_32 (output_bfd, (bfd_vma) 0,
2405                         htab->sgotplt->contents);
2406           else
2407             bfd_put_32 (output_bfd,
2408                         ds.sdyn->output_section->vma + ds.sdyn->output_offset,
2409                         htab->sgotplt->contents);
2410           bfd_put_32 (output_bfd, (bfd_vma) 0, htab->sgotplt->contents + 4);
2411           bfd_put_32 (output_bfd, (bfd_vma) 0, htab->sgotplt->contents + 8);
2412         }
2413     }
2414
2415   return TRUE;
2416 }
2417
2418 #define ADD_DYNAMIC_SYMBOL(NAME, TAG)                                   \
2419   h =  elf_link_hash_lookup (elf_hash_table (info),                     \
2420                              NAME, FALSE, FALSE, FALSE);                \
2421   if ((h != NULL && (h->ref_regular || h->def_regular)))                \
2422     if (! _bfd_elf_add_dynamic_entry (info, TAG, 0))                    \
2423       return FALSE;
2424
2425 /* Set the sizes of the dynamic sections.  */
2426 static bfd_boolean
2427 elf_arc_size_dynamic_sections (bfd * output_bfd,
2428                                struct bfd_link_info *info)
2429 {
2430   bfd *    dynobj;
2431   asection *      s;
2432   bfd_boolean     relocs_exist = FALSE;
2433   bfd_boolean     reltext_exist = FALSE;
2434   struct dynamic_sections ds = arc_create_dynamic_sections (output_bfd, info);
2435   struct elf_link_hash_table *htab = elf_hash_table (info);
2436
2437   dynobj = (elf_hash_table (info))->dynobj;
2438   BFD_ASSERT (dynobj != NULL);
2439
2440   if ((elf_hash_table (info))->dynamic_sections_created)
2441     {
2442       struct elf_link_hash_entry *h;
2443
2444       /* Set the contents of the .interp section to the
2445          interpreter.  */
2446       if (!bfd_link_pic (info))
2447         {
2448           s = bfd_get_section_by_name (dynobj, ".interp");
2449           BFD_ASSERT (s != NULL);
2450           s->size = sizeof (ELF_DYNAMIC_INTERPRETER);
2451           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
2452         }
2453
2454       /* Add some entries to the .dynamic section.  We fill in some of
2455          the values later, in elf_bfd_final_link, but we must add the
2456          entries now so that we know the final size of the .dynamic
2457          section.  Checking if the .init section is present.  We also
2458          create DT_INIT and DT_FINI entries if the init_str has been
2459          changed by the user.  */
2460       ADD_DYNAMIC_SYMBOL ("init", DT_INIT);
2461       ADD_DYNAMIC_SYMBOL ("fini", DT_FINI);
2462     }
2463   else
2464     {
2465       /* We may have created entries in the .rela.got section.
2466          However, if we are not creating the dynamic sections, we will
2467          not actually use these entries.  Reset the size of .rela.got,
2468          which will cause it to get stripped from the output file
2469          below.  */
2470       if (htab->srelgot != NULL)
2471         htab->srelgot->size = 0;
2472     }
2473
2474   if (htab->splt != NULL && htab->splt->size == 0)
2475     htab->splt->flags |= SEC_EXCLUDE;
2476   for (s = dynobj->sections; s != NULL; s = s->next)
2477     {
2478       if ((s->flags & SEC_LINKER_CREATED) == 0)
2479         continue;
2480
2481       if (strncmp (s->name, ".rela", 5) == 0)
2482         {
2483           if (s->size == 0)
2484             {
2485               s->flags |= SEC_EXCLUDE;
2486             }
2487           else
2488             {
2489               if (strcmp (s->name, ".rela.plt") != 0)
2490                 {
2491                   const char *outname =
2492                     bfd_get_section_name (output_bfd,
2493                                           htab->srelplt->output_section);
2494
2495                   asection *target = bfd_get_section_by_name (output_bfd,
2496                                                               outname + 4);
2497
2498                   relocs_exist = TRUE;
2499                   if (target != NULL && target->size != 0
2500                       && (target->flags & SEC_READONLY) != 0
2501                       && (target->flags & SEC_ALLOC) != 0)
2502                     reltext_exist = TRUE;
2503                 }
2504             }
2505
2506           /* We use the reloc_count field as a counter if we need to
2507              copy relocs into the output file.  */
2508           s->reloc_count = 0;
2509         }
2510
2511       if (strcmp (s->name, ".dynamic") == 0)
2512         continue;
2513
2514       if (s->size != 0)
2515         s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
2516
2517       if (s->contents == NULL && s->size != 0)
2518         return FALSE;
2519     }
2520
2521   if (ds.sdyn)
2522     {
2523       /* TODO: Check if this is needed.  */
2524       if (!bfd_link_pic (info))
2525         if (!_bfd_elf_add_dynamic_entry (info, DT_DEBUG, 0))
2526                 return FALSE;
2527
2528       if (htab->splt && (htab->splt->flags & SEC_EXCLUDE) == 0)
2529         if (!_bfd_elf_add_dynamic_entry (info, DT_PLTGOT, 0)
2530             || !_bfd_elf_add_dynamic_entry (info, DT_PLTRELSZ, 0)
2531             || !_bfd_elf_add_dynamic_entry (info, DT_PLTREL, DT_RELA)
2532             || !_bfd_elf_add_dynamic_entry (info, DT_JMPREL, 0)
2533            )
2534           return FALSE;
2535
2536       if (relocs_exist == TRUE)
2537         if (!_bfd_elf_add_dynamic_entry (info, DT_RELA, 0)
2538             || !_bfd_elf_add_dynamic_entry (info, DT_RELASZ, 0)
2539             || !_bfd_elf_add_dynamic_entry (info, DT_RELENT,
2540                                             sizeof (Elf32_External_Rela))
2541            )
2542           return FALSE;
2543
2544       if (reltext_exist == TRUE)
2545         if (!_bfd_elf_add_dynamic_entry (info, DT_TEXTREL, 0))
2546           return FALSE;
2547     }
2548
2549   return TRUE;
2550 }
2551
2552 const struct elf_size_info arc_elf32_size_info =
2553 {
2554   sizeof (Elf32_External_Ehdr),
2555   sizeof (Elf32_External_Phdr),
2556   sizeof (Elf32_External_Shdr),
2557   sizeof (Elf32_External_Rel),
2558   sizeof (Elf32_External_Rela),
2559   sizeof (Elf32_External_Sym),
2560   sizeof (Elf32_External_Dyn),
2561   sizeof (Elf_External_Note),
2562   4,
2563   1,
2564   32, 2,
2565   ELFCLASS32, EV_CURRENT,
2566   bfd_elf32_write_out_phdrs,
2567   bfd_elf32_write_shdrs_and_ehdr,
2568   bfd_elf32_checksum_contents,
2569   bfd_elf32_write_relocs,
2570   bfd_elf32_swap_symbol_in,
2571   bfd_elf32_swap_symbol_out,
2572   bfd_elf32_slurp_reloc_table,
2573   bfd_elf32_slurp_symbol_table,
2574   bfd_elf32_swap_dyn_in,
2575   bfd_elf32_swap_dyn_out,
2576   bfd_elf32_swap_reloc_in,
2577   bfd_elf32_swap_reloc_out,
2578   bfd_elf32_swap_reloca_in,
2579   bfd_elf32_swap_reloca_out
2580 };
2581
2582 #define elf_backend_size_info           arc_elf32_size_info
2583
2584 static struct bfd_link_hash_table *
2585 arc_elf_link_hash_table_create (bfd *abfd)
2586 {
2587   struct elf_link_hash_table *htab;
2588
2589   htab = bfd_zmalloc (sizeof (*htab));
2590   if (htab == NULL)
2591     return NULL;
2592
2593   if (!_bfd_elf_link_hash_table_init (htab, abfd,
2594                                       _bfd_elf_link_hash_newfunc,
2595                                       sizeof (struct elf_link_hash_entry),
2596                                       GENERIC_ELF_DATA))
2597     {
2598       free (htab);
2599       return NULL;
2600     }
2601
2602   htab->init_got_refcount.refcount = 0;
2603   htab->init_got_refcount.glist = NULL;
2604   htab->init_got_offset.offset = 0;
2605   htab->init_got_offset.glist = NULL;
2606   return (struct bfd_link_hash_table *) htab;
2607 }
2608
2609 /* Hook called by the linker routine which adds symbols from an object
2610    file.  */
2611
2612 static bfd_boolean
2613 elf_arc_add_symbol_hook (bfd * abfd,
2614                          struct bfd_link_info * info,
2615                          Elf_Internal_Sym * sym,
2616                          const char ** namep ATTRIBUTE_UNUSED,
2617                          flagword * flagsp ATTRIBUTE_UNUSED,
2618                          asection ** secp ATTRIBUTE_UNUSED,
2619                          bfd_vma * valp ATTRIBUTE_UNUSED)
2620 {
2621   if ((ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC
2622        || ELF_ST_BIND (sym->st_info) == STB_GNU_UNIQUE)
2623       && (abfd->flags & DYNAMIC) == 0
2624       && bfd_get_flavour (info->output_bfd) == bfd_target_elf_flavour)
2625     elf_tdata (info->output_bfd)->has_gnu_symbols = elf_gnu_symbol_any;
2626
2627   return TRUE;
2628 }
2629
2630 #define TARGET_LITTLE_SYM   arc_elf32_le_vec
2631 #define TARGET_LITTLE_NAME  "elf32-littlearc"
2632 #define TARGET_BIG_SYM      arc_elf32_be_vec
2633 #define TARGET_BIG_NAME     "elf32-bigarc"
2634 #define ELF_ARCH            bfd_arch_arc
2635 #define ELF_MACHINE_CODE    EM_ARC_COMPACT
2636 #define ELF_MACHINE_ALT1    EM_ARC_COMPACT2
2637 #define ELF_MAXPAGESIZE     0x2000
2638
2639 #define bfd_elf32_bfd_link_hash_table_create    arc_elf_link_hash_table_create
2640
2641 #define bfd_elf32_bfd_merge_private_bfd_data    arc_elf_merge_private_bfd_data
2642 #define bfd_elf32_bfd_reloc_type_lookup         arc_elf32_bfd_reloc_type_lookup
2643 #define bfd_elf32_bfd_set_private_flags         arc_elf_set_private_flags
2644 #define bfd_elf32_bfd_print_private_bfd_data    arc_elf_print_private_bfd_data
2645 #define bfd_elf32_bfd_copy_private_bfd_data     arc_elf_copy_private_bfd_data
2646
2647 #define elf_info_to_howto_rel                arc_info_to_howto_rel
2648 #define elf_backend_object_p                 arc_elf_object_p
2649 #define elf_backend_final_write_processing   arc_elf_final_write_processing
2650
2651 #define elf_backend_relocate_section         elf_arc_relocate_section
2652 #define elf_backend_check_relocs             elf_arc_check_relocs
2653 #define elf_backend_create_dynamic_sections  _bfd_elf_create_dynamic_sections
2654
2655 #define elf_backend_adjust_dynamic_symbol    elf_arc_adjust_dynamic_symbol
2656 #define elf_backend_finish_dynamic_symbol    elf_arc_finish_dynamic_symbol
2657
2658 #define elf_backend_finish_dynamic_sections  elf_arc_finish_dynamic_sections
2659 #define elf_backend_size_dynamic_sections    elf_arc_size_dynamic_sections
2660 #define elf_backend_add_symbol_hook          elf_arc_add_symbol_hook
2661
2662 #define elf_backend_can_gc_sections     1
2663 #define elf_backend_want_got_plt        1
2664 #define elf_backend_plt_readonly        1
2665 #define elf_backend_rela_plts_and_copies_p 1
2666 #define elf_backend_want_plt_sym        0
2667 #define elf_backend_got_header_size     12
2668
2669 #define elf_backend_may_use_rel_p       0
2670 #define elf_backend_may_use_rela_p      1
2671 #define elf_backend_default_use_rela_p  1
2672
2673 #include "elf32-target.h"