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