bfd/elf32-arc.c

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