bfd/elf32-arc.c

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