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