bfd/elf32-arc.c

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