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