bfd/elf32-arc.c

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