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