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