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