/[gcl]/gcl/binutils/bfd/elf32-frv.c
ViewVC logotype

Diff of /gcl/binutils/bfd/elf32-frv.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1.1.1.1 by camm, Fri Aug 9 05:36:06 2002 UTC revision 1.2 by camm, Fri Sep 9 23:32:09 2005 UTC
# Line 1  Line 1 
1  /* FRV-specific support for 32-bit ELF.  /* FRV-specific support for 32-bit ELF.
2     Copyright (C) 2002 Free Software Foundation, Inc.     Copyright 2002, 2003, 2004, 2005  Free Software Foundation, Inc.
3    
4  This file is part of BFD, the Binary File Descriptor library.  This file is part of BFD, the Binary File Descriptor library.
5    
# Line 22  Foundation, Inc., 59 Temple Place - Suit Line 22  Foundation, Inc., 59 Temple Place - Suit
22  #include "libbfd.h"  #include "libbfd.h"
23  #include "elf-bfd.h"  #include "elf-bfd.h"
24  #include "elf/frv.h"  #include "elf/frv.h"
25    #include "elf/dwarf2.h"
26    #include "hashtab.h"
27    
28  /* Forward declarations.  */  /* Forward declarations.  */
29  static bfd_reloc_status_type elf32_frv_relocate_lo16  static bfd_reloc_status_type elf32_frv_relocate_lo16
# Line 31  static bfd_reloc_status_type elf32_frv_r Line 33  static bfd_reloc_status_type elf32_frv_r
33  static bfd_reloc_status_type elf32_frv_relocate_label24  static bfd_reloc_status_type elf32_frv_relocate_label24
34    PARAMS ((bfd *, asection *, Elf_Internal_Rela *, bfd_byte *, bfd_vma));    PARAMS ((bfd *, asection *, Elf_Internal_Rela *, bfd_byte *, bfd_vma));
35  static bfd_reloc_status_type elf32_frv_relocate_gprel12  static bfd_reloc_status_type elf32_frv_relocate_gprel12
36    PARAMS ((struct bfd_link_info *, bfd *, asection *, Elf_Internal_Rela *, bfd_byte *, bfd_vma));    PARAMS ((struct bfd_link_info *, bfd *, asection *, Elf_Internal_Rela *,
37               bfd_byte *, bfd_vma));
38  static bfd_reloc_status_type elf32_frv_relocate_gprelu12  static bfd_reloc_status_type elf32_frv_relocate_gprelu12
39    PARAMS ((struct bfd_link_info *, bfd *, asection *, Elf_Internal_Rela *, bfd_byte *, bfd_vma));    PARAMS ((struct bfd_link_info *, bfd *, asection *, Elf_Internal_Rela *,
40               bfd_byte *, bfd_vma));
41  static bfd_reloc_status_type elf32_frv_relocate_gprello  static bfd_reloc_status_type elf32_frv_relocate_gprello
42    PARAMS ((struct bfd_link_info *, bfd *, asection *, Elf_Internal_Rela *, bfd_byte *, bfd_vma));    PARAMS ((struct bfd_link_info *, bfd *, asection *, Elf_Internal_Rela *,
43               bfd_byte *, bfd_vma));
44  static bfd_reloc_status_type elf32_frv_relocate_gprelhi  static bfd_reloc_status_type elf32_frv_relocate_gprelhi
45    PARAMS ((struct bfd_link_info *, bfd *, asection *, Elf_Internal_Rela *, bfd_byte *, bfd_vma));    PARAMS ((struct bfd_link_info *, bfd *, asection *, Elf_Internal_Rela *,
46               bfd_byte *, bfd_vma));
47  static reloc_howto_type *frv_reloc_type_lookup  static reloc_howto_type *frv_reloc_type_lookup
48    PARAMS ((bfd *, bfd_reloc_code_real_type));    PARAMS ((bfd *, bfd_reloc_code_real_type));
49  static void frv_info_to_howto_rela  static void frv_info_to_howto_rela
50    PARAMS ((bfd *, arelent *, Elf32_Internal_Rela *));    PARAMS ((bfd *, arelent *, Elf_Internal_Rela *));
51  static boolean elf32_frv_relocate_section  static bfd_boolean elf32_frv_relocate_section
52    PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *, Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));    PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
53  static boolean elf32_frv_add_symbol_hook             Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
54    PARAMS (( bfd *, struct bfd_link_info *, const Elf_Internal_Sym *, const char **, flagword *, asection **, bfd_vma *));  static bfd_boolean elf32_frv_add_symbol_hook
55      PARAMS (( bfd *, struct bfd_link_info *, Elf_Internal_Sym *,
56                const char **, flagword *, asection **, bfd_vma *));
57  static bfd_reloc_status_type frv_final_link_relocate  static bfd_reloc_status_type frv_final_link_relocate
58    PARAMS ((reloc_howto_type *, bfd *, asection *, bfd_byte *, Elf_Internal_Rela *, bfd_vma));    PARAMS ((reloc_howto_type *, bfd *, asection *, bfd_byte *,
59  static boolean elf32_frv_gc_sweep_hook             Elf_Internal_Rela *, bfd_vma));
60    PARAMS ((bfd *, struct bfd_link_info *, asection *, const Elf_Internal_Rela *));  static bfd_boolean elf32_frv_gc_sweep_hook
61      PARAMS ((bfd *, struct bfd_link_info *, asection *, const
62               Elf_Internal_Rela *));
63  static asection * elf32_frv_gc_mark_hook  static asection * elf32_frv_gc_mark_hook
64    PARAMS ((asection *, struct bfd_link_info *, Elf_Internal_Rela *, struct elf_link_hash_entry *, Elf_Internal_Sym *));    PARAMS ((asection *, struct bfd_link_info *, Elf_Internal_Rela *,
65  static boolean elf32_frv_check_relocs             struct elf_link_hash_entry *, Elf_Internal_Sym *));
66    PARAMS ((bfd *, struct bfd_link_info *, asection *, const Elf_Internal_Rela *));  static bfd_boolean elf32_frv_check_relocs
67  static int elf32_frv_machine PARAMS ((bfd *));    PARAMS ((bfd *, struct bfd_link_info *, asection *,
68  static boolean elf32_frv_object_p PARAMS ((bfd *));             const Elf_Internal_Rela *));
69  static boolean frv_elf_set_private_flags PARAMS ((bfd *, flagword));  static int elf32_frv_machine
70  static boolean frv_elf_copy_private_bfd_data PARAMS ((bfd *, bfd *));    PARAMS ((bfd *));
71  static boolean frv_elf_merge_private_bfd_data PARAMS ((bfd *, bfd *));  static bfd_boolean elf32_frv_object_p
72  static boolean frv_elf_print_private_bfd_data PARAMS ((bfd *, PTR));    PARAMS ((bfd *));
73    static bfd_boolean frv_elf_set_private_flags
74      PARAMS ((bfd *, flagword));
75    static bfd_boolean frv_elf_copy_private_bfd_data
76      PARAMS ((bfd *, bfd *));
77    static bfd_boolean frv_elf_merge_private_bfd_data
78      PARAMS ((bfd *, bfd *));
79    static bfd_boolean frv_elf_print_private_bfd_data
80      PARAMS ((bfd *, PTR));
81    
82  static reloc_howto_type elf32_frv_howto_table [] =  static reloc_howto_type elf32_frv_howto_table [] =
83  {  {
# Line 68  static reloc_howto_type elf32_frv_howto_ Line 86  static reloc_howto_type elf32_frv_howto_
86           0,                     /* rightshift */           0,                     /* rightshift */
87           2,                     /* size (0 = byte, 1 = short, 2 = long) */           2,                     /* size (0 = byte, 1 = short, 2 = long) */
88           32,                    /* bitsize */           32,                    /* bitsize */
89           false,                 /* pc_relative */           FALSE,                 /* pc_relative */
90           0,                     /* bitpos */           0,                     /* bitpos */
91           complain_overflow_bitfield, /* complain_on_overflow */           complain_overflow_bitfield, /* complain_on_overflow */
92           bfd_elf_generic_reloc, /* special_function */           bfd_elf_generic_reloc, /* special_function */
93           "R_FRV_NONE",          /* name */           "R_FRV_NONE",          /* name */
94           false,                 /* partial_inplace */           FALSE,                 /* partial_inplace */
95           0,                     /* src_mask */           0,                     /* src_mask */
96           0,                     /* dst_mask */           0,                     /* dst_mask */
97           false),                /* pcrel_offset */           FALSE),                /* pcrel_offset */
98    
99    /* A 32 bit absolute relocation.  */    /* A 32 bit absolute relocation.  */
100    HOWTO (R_FRV_32,              /* type */    HOWTO (R_FRV_32,              /* type */
101           0,                     /* rightshift */           0,                     /* rightshift */
102           2,                     /* size (0 = byte, 1 = short, 2 = long) */           2,                     /* size (0 = byte, 1 = short, 2 = long) */
103           32,                    /* bitsize */           32,                    /* bitsize */
104           false,                 /* pc_relative */           FALSE,                 /* pc_relative */
105           0,                     /* bitpos */           0,                     /* bitpos */
106           complain_overflow_bitfield, /* complain_on_overflow */           complain_overflow_bitfield, /* complain_on_overflow */
107           bfd_elf_generic_reloc, /* special_function */           bfd_elf_generic_reloc, /* special_function */
108           "R_FRV_32",            /* name */           "R_FRV_32",            /* name */
109           false,                 /* partial_inplace */           FALSE,                 /* partial_inplace */
110           0xffffffff,            /* src_mask */           0xffffffff,            /* src_mask */
111           0xffffffff,            /* dst_mask */           0xffffffff,            /* dst_mask */
112           false),                /* pcrel_offset */           FALSE),                /* pcrel_offset */
113    
114    /* A 16 bit pc-relative relocation.  */    /* A 16 bit pc-relative relocation.  */
115    HOWTO (R_FRV_LABEL16,         /* type */    HOWTO (R_FRV_LABEL16,         /* type */
116           0,                     /* rightshift */           2,                     /* rightshift */
117           2,                     /* size (0 = byte, 1 = short, 2 = long) */           2,                     /* size (0 = byte, 1 = short, 2 = long) */
118           16,                    /* bitsize */           16,                    /* bitsize */
119           true,                  /* pc_relative */           TRUE,                  /* pc_relative */
120           0,                     /* bitpos */           0,                     /* bitpos */
121           complain_overflow_bitfield, /* complain_on_overflow */           complain_overflow_signed, /* complain_on_overflow */
122           bfd_elf_generic_reloc, /* special_function */           bfd_elf_generic_reloc, /* special_function */
123           "R_FRV_LABEL16",       /* name */           "R_FRV_LABEL16",       /* name */
124           false,                 /* partial_inplace */           FALSE,                 /* partial_inplace */
125           0xffff,                /* src_mask */           0xffff,                /* src_mask */
126           0xffff,                /* dst_mask */           0xffff,                /* dst_mask */
127           true),                 /* pcrel_offset */           TRUE),                 /* pcrel_offset */
128    
129    /* A 24-bit pc-relative relocation.  */    /* A 24-bit pc-relative relocation.  */
130    HOWTO (R_FRV_LABEL24, /* type */    HOWTO (R_FRV_LABEL24, /* type */
131           2,                     /* rightshift */           2,                     /* rightshift */
132           2,                     /* size (0 = byte, 1 = short, 2 = long) */           2,                     /* size (0 = byte, 1 = short, 2 = long) */
133           26,                    /* bitsize */           26,                    /* bitsize */
134           true,                  /* pc_relative */           TRUE,                  /* pc_relative */
135           0,                     /* bitpos */           0,                     /* bitpos */
136           complain_overflow_bitfield, /* complain_on_overflow */           complain_overflow_bitfield, /* complain_on_overflow */
137           bfd_elf_generic_reloc, /* special_function */           bfd_elf_generic_reloc, /* special_function */
138           "R_FRV_LABEL24",       /* name */           "R_FRV_LABEL24",       /* name */
139           false,                 /* partial_inplace */           FALSE,                 /* partial_inplace */
140           0x7e03ffff,            /* src_mask */           0x7e03ffff,            /* src_mask */
141           0x7e03ffff,            /* dst_mask */           0x7e03ffff,            /* dst_mask */
142           true),                 /* pcrel_offset */           TRUE),                 /* pcrel_offset */
143    
144    HOWTO (R_FRV_LO16,            /* type */    HOWTO (R_FRV_LO16,            /* type */
145           0,                     /* rightshift */           0,                     /* rightshift */
146           2,                     /* size (0 = byte, 1 = short, 2 = long) */           2,                     /* size (0 = byte, 1 = short, 2 = long) */
147           16,                    /* bitsize */           16,                    /* bitsize */
148           false,                 /* pc_relative */           FALSE,                 /* pc_relative */
149           0,                     /* bitpos */           0,                     /* bitpos */
150           complain_overflow_dont, /* complain_on_overflow */           complain_overflow_dont, /* complain_on_overflow */
151           bfd_elf_generic_reloc, /* special_function */           bfd_elf_generic_reloc, /* special_function */
152           "R_FRV_LO16",          /* name */           "R_FRV_LO16",          /* name */
153          false,                  /* partial_inplace */           FALSE,                 /* partial_inplace */
154           0xffff,                /* src_mask */           0xffff,                /* src_mask */
155           0xffff,                /* dst_mask */           0xffff,                /* dst_mask */
156           false),                /* pcrel_offset */           FALSE),                /* pcrel_offset */
157    
158    HOWTO (R_FRV_HI16,            /* type */    HOWTO (R_FRV_HI16,            /* type */
159           0,                     /* rightshift */           0,                     /* rightshift */
160           2,                     /* size (0 = byte, 1 = short, 2 = long) */           2,                     /* size (0 = byte, 1 = short, 2 = long) */
161           16,                    /* bitsize */           16,                    /* bitsize */
162           false,                 /* pc_relative */           FALSE,                 /* pc_relative */
163           0,                     /* bitpos */           0,                     /* bitpos */
164           complain_overflow_dont, /* complain_on_overflow */           complain_overflow_dont, /* complain_on_overflow */
165           bfd_elf_generic_reloc, /* special_function */           bfd_elf_generic_reloc, /* special_function */
166           "R_FRV_HI16",          /* name */           "R_FRV_HI16",          /* name */
167           false,                 /* partial_inplace */           FALSE,                 /* partial_inplace */
168           0xffff,                /* src_mask */           0xffff,                /* src_mask */
169           0xffff,                /* dst_mask */           0xffff,                /* dst_mask */
170           false),                /* pcrel_offset */           FALSE),                /* pcrel_offset */
171    
172    HOWTO (R_FRV_GPREL12,         /* type */    HOWTO (R_FRV_GPREL12,         /* type */
173           0,                     /* rightshift */           0,                     /* rightshift */
174           2,                     /* size (0 = byte, 1 = short, 2 = long) */           2,                     /* size (0 = byte, 1 = short, 2 = long) */
175           12,                    /* bitsize */           12,                    /* bitsize */
176           false,                 /* pc_relative */           FALSE,                 /* pc_relative */
177           0,                     /* bitpos */           0,                     /* bitpos */
178           complain_overflow_dont, /* complain_on_overflow */           complain_overflow_dont, /* complain_on_overflow */
179           bfd_elf_generic_reloc, /* special_function */           bfd_elf_generic_reloc, /* special_function */
180           "R_FRV_GPREL12",       /* name */           "R_FRV_GPREL12",       /* name */
181           false,                 /* partial_inplace */           FALSE,                 /* partial_inplace */
182           0xfff,                 /* src_mask */           0xfff,                 /* src_mask */
183           0xfff,                 /* dst_mask */           0xfff,                 /* dst_mask */
184           false),                /* pcrel_offset */           FALSE),                /* pcrel_offset */
185    
186    HOWTO (R_FRV_GPRELU12,        /* type */    HOWTO (R_FRV_GPRELU12,        /* type */
187           0,                     /* rightshift */           0,                     /* rightshift */
188           2,                     /* size (0 = byte, 1 = short, 2 = long) */           2,                     /* size (0 = byte, 1 = short, 2 = long) */
189           12,                    /* bitsize */           12,                    /* bitsize */
190           false,                 /* pc_relative */           FALSE,                 /* pc_relative */
191           0,                     /* bitpos */           0,                     /* bitpos */
192           complain_overflow_dont, /* complain_on_overflow */           complain_overflow_dont, /* complain_on_overflow */
193           bfd_elf_generic_reloc, /* special_function */           bfd_elf_generic_reloc, /* special_function */
194           "R_FRV_GPRELU12",      /* name */           "R_FRV_GPRELU12",      /* name */
195           false,                 /* partial_inplace */           FALSE,                 /* partial_inplace */
196           0xfff,                 /* src_mask */           0xfff,                 /* src_mask */
197           0x3f03f,               /* dst_mask */           0x3f03f,               /* dst_mask */
198           false),                /* pcrel_offset */           FALSE),                /* pcrel_offset */
199    
200    HOWTO (R_FRV_GPREL32,         /* type */    HOWTO (R_FRV_GPREL32,         /* type */
201           0,                     /* rightshift */           0,                     /* rightshift */
202           2,                     /* size (0 = byte, 1 = short, 2 = long) */           2,                     /* size (0 = byte, 1 = short, 2 = long) */
203           32,                    /* bitsize */           32,                    /* bitsize */
204           false,                 /* pc_relative */           FALSE,                 /* pc_relative */
205           0,                     /* bitpos */           0,                     /* bitpos */
206           complain_overflow_dont, /* complain_on_overflow */           complain_overflow_dont, /* complain_on_overflow */
207           bfd_elf_generic_reloc, /* special_function */           bfd_elf_generic_reloc, /* special_function */
208           "R_FRV_GPREL32",       /* name */           "R_FRV_GPREL32",       /* name */
209           false,                 /* partial_inplace */           FALSE,                 /* partial_inplace */
210           0xffffffff,            /* src_mask */           0xffffffff,            /* src_mask */
211           0xffffffff,            /* dst_mask */           0xffffffff,            /* dst_mask */
212           false),                /* pcrel_offset */           FALSE),                /* pcrel_offset */
213    
214    HOWTO (R_FRV_GPRELHI,         /* type */    HOWTO (R_FRV_GPRELHI,         /* type */
215           0,                     /* rightshift */           0,                     /* rightshift */
216           2,                     /* size (0 = byte, 1 = short, 2 = long) */           2,                     /* size (0 = byte, 1 = short, 2 = long) */
217           16,                    /* bitsize */           16,                    /* bitsize */
218           false,                 /* pc_relative */           FALSE,                 /* pc_relative */
219           0,                     /* bitpos */           0,                     /* bitpos */
220           complain_overflow_dont, /* complain_on_overflow */           complain_overflow_dont, /* complain_on_overflow */
221           bfd_elf_generic_reloc, /* special_function */           bfd_elf_generic_reloc, /* special_function */
222           "R_FRV_GPRELHI",       /* name */           "R_FRV_GPRELHI",       /* name */
223           false,                 /* partial_inplace */           FALSE,                 /* partial_inplace */
224           0xffff,                        /* src_mask */           0xffff,                        /* src_mask */
225           0xffff,                /* dst_mask */           0xffff,                /* dst_mask */
226           false),                /* pcrel_offset */           FALSE),                /* pcrel_offset */
227    
228    HOWTO (R_FRV_GPRELLO,         /* type */    HOWTO (R_FRV_GPRELLO,         /* type */
229           0,                     /* rightshift */           0,                     /* rightshift */
230           2,                     /* size (0 = byte, 1 = short, 2 = long) */           2,                     /* size (0 = byte, 1 = short, 2 = long) */
231           16,                    /* bitsize */           16,                    /* bitsize */
232           false,                 /* pc_relative */           FALSE,                 /* pc_relative */
233           0,                     /* bitpos */           0,                     /* bitpos */
234           complain_overflow_dont, /* complain_on_overflow */           complain_overflow_dont, /* complain_on_overflow */
235           bfd_elf_generic_reloc, /* special_function */           bfd_elf_generic_reloc, /* special_function */
236           "R_FRV_GPRELLO",       /* name */           "R_FRV_GPRELLO",       /* name */
237           false,                 /* partial_inplace */           FALSE,                 /* partial_inplace */
238             0xffff,                        /* src_mask */
239             0xffff,                /* dst_mask */
240             FALSE),                /* pcrel_offset */
241    
242      /* A 12-bit signed operand with the GOT offset for the address of
243         the symbol.  */
244      HOWTO (R_FRV_GOT12,           /* type */
245             0,                     /* rightshift */
246             2,                     /* size (0 = byte, 1 = short, 2 = long) */
247             12,                    /* bitsize */
248             FALSE,                 /* pc_relative */
249             0,                     /* bitpos */
250             complain_overflow_signed, /* complain_on_overflow */
251             bfd_elf_generic_reloc, /* special_function */
252             "R_FRV_GOT12",         /* name */
253             FALSE,                 /* partial_inplace */
254             0xfff,                 /* src_mask */
255             0xfff,                 /* dst_mask */
256             FALSE),                /* pcrel_offset */
257    
258      /* The upper 16 bits of the GOT offset for the address of the
259         symbol.  */
260      HOWTO (R_FRV_GOTHI,           /* type */
261             0,                     /* rightshift */
262             2,                     /* size (0 = byte, 1 = short, 2 = long) */
263             16,                    /* bitsize */
264             FALSE,                 /* pc_relative */
265             0,                     /* bitpos */
266             complain_overflow_dont, /* complain_on_overflow */
267             bfd_elf_generic_reloc, /* special_function */
268             "R_FRV_GOTHI",         /* name */
269             FALSE,                 /* partial_inplace */
270           0xffff,                        /* src_mask */           0xffff,                        /* src_mask */
271           0xffff,                /* dst_mask */           0xffff,                /* dst_mask */
272           false),                /* pcrel_offset */           FALSE),                /* pcrel_offset */
273    
274      /* The lower 16 bits of the GOT offset for the address of the
275         symbol.  */
276      HOWTO (R_FRV_GOTLO,           /* type */
277             0,                     /* rightshift */
278             2,                     /* size (0 = byte, 1 = short, 2 = long) */
279             16,                    /* bitsize */
280             FALSE,                 /* pc_relative */
281             0,                     /* bitpos */
282             complain_overflow_dont, /* complain_on_overflow */
283             bfd_elf_generic_reloc, /* special_function */
284             "R_FRV_GOTLO",         /* name */
285             FALSE,                 /* partial_inplace */
286             0xffff,                /* src_mask */
287             0xffff,                /* dst_mask */
288             FALSE),                /* pcrel_offset */
289    
290      /* The 32-bit address of the canonical descriptor of a function.  */
291      HOWTO (R_FRV_FUNCDESC,        /* type */
292             0,                     /* rightshift */
293             2,                     /* size (0 = byte, 1 = short, 2 = long) */
294             32,                    /* bitsize */
295             FALSE,                 /* pc_relative */
296             0,                     /* bitpos */
297             complain_overflow_bitfield, /* complain_on_overflow */
298             bfd_elf_generic_reloc, /* special_function */
299             "R_FRV_FUNCDESC",      /* name */
300             FALSE,                 /* partial_inplace */
301             0xffffffff,            /* src_mask */
302             0xffffffff,            /* dst_mask */
303             FALSE),                /* pcrel_offset */
304    
305      /* A 12-bit signed operand with the GOT offset for the address of
306         canonical descriptor of a function.  */
307      HOWTO (R_FRV_FUNCDESC_GOT12,  /* type */
308             0,                     /* rightshift */
309             2,                     /* size (0 = byte, 1 = short, 2 = long) */
310             12,                    /* bitsize */
311             FALSE,                 /* pc_relative */
312             0,                     /* bitpos */
313             complain_overflow_signed, /* complain_on_overflow */
314             bfd_elf_generic_reloc, /* special_function */
315             "R_FRV_FUNCDESC_GOT12", /* name */
316             FALSE,                 /* partial_inplace */
317             0xfff,                 /* src_mask */
318             0xfff,                 /* dst_mask */
319             FALSE),                /* pcrel_offset */
320    
321      /* The upper 16 bits of the GOT offset for the address of the
322         canonical descriptor of a function.  */
323      HOWTO (R_FRV_FUNCDESC_GOTHI,  /* type */
324             0,                     /* rightshift */
325             2,                     /* size (0 = byte, 1 = short, 2 = long) */
326             16,                    /* bitsize */
327             FALSE,                 /* pc_relative */
328             0,                     /* bitpos */
329             complain_overflow_dont, /* complain_on_overflow */
330             bfd_elf_generic_reloc, /* special_function */
331             "R_FRV_FUNCDESC_GOTHI", /* name */
332             FALSE,                 /* partial_inplace */
333             0xffff,                /* src_mask */
334             0xffff,                /* dst_mask */
335             FALSE),                /* pcrel_offset */
336    
337      /* The lower 16 bits of the GOT offset for the address of the
338         canonical descriptor of a function.  */
339      HOWTO (R_FRV_FUNCDESC_GOTLO,  /* type */
340             0,                     /* rightshift */
341             2,                     /* size (0 = byte, 1 = short, 2 = long) */
342             16,                    /* bitsize */
343             FALSE,                 /* pc_relative */
344             0,                     /* bitpos */
345             complain_overflow_dont, /* complain_on_overflow */
346             bfd_elf_generic_reloc, /* special_function */
347             "R_FRV_FUNCDESC_GOTLO", /* name */
348             FALSE,                 /* partial_inplace */
349             0xffff,                /* src_mask */
350             0xffff,                /* dst_mask */
351             FALSE),                /* pcrel_offset */
352    
353      /* The 64-bit descriptor of a function.  */
354      HOWTO (R_FRV_FUNCDESC_VALUE,  /* type */
355             0,                     /* rightshift */
356             2,                     /* size (0 = byte, 1 = short, 2 = long) */
357             64,                    /* bitsize */
358             FALSE,                 /* pc_relative */
359             0,                     /* bitpos */
360             complain_overflow_bitfield, /* complain_on_overflow */
361             bfd_elf_generic_reloc, /* special_function */
362             "R_FRV_FUNCDESC_VALUE", /* name */
363             FALSE,                 /* partial_inplace */
364             0xffffffff,            /* src_mask */
365             0xffffffff,            /* dst_mask */
366             FALSE),                /* pcrel_offset */
367    
368      /* A 12-bit signed operand with the GOT offset for the address of
369         canonical descriptor of a function.  */
370      HOWTO (R_FRV_FUNCDESC_GOTOFF12, /* type */
371             0,                     /* rightshift */
372             2,                     /* size (0 = byte, 1 = short, 2 = long) */
373             12,                    /* bitsize */
374             FALSE,                 /* pc_relative */
375             0,                     /* bitpos */
376             complain_overflow_signed, /* complain_on_overflow */
377             bfd_elf_generic_reloc, /* special_function */
378             "R_FRV_FUNCDESC_GOTOFF12", /* name */
379             FALSE,                 /* partial_inplace */
380             0xfff,                 /* src_mask */
381             0xfff,                 /* dst_mask */
382             FALSE),                /* pcrel_offset */
383    
384      /* The upper 16 bits of the GOT offset for the address of the
385         canonical descriptor of a function.  */
386      HOWTO (R_FRV_FUNCDESC_GOTOFFHI, /* type */
387             0,                     /* rightshift */
388             2,                     /* size (0 = byte, 1 = short, 2 = long) */
389             16,                    /* bitsize */
390             FALSE,                 /* pc_relative */
391             0,                     /* bitpos */
392             complain_overflow_dont, /* complain_on_overflow */
393             bfd_elf_generic_reloc, /* special_function */
394             "R_FRV_FUNCDESC_GOTOFFHI", /* name */
395             FALSE,                 /* partial_inplace */
396             0xffff,                /* src_mask */
397             0xffff,                /* dst_mask */
398             FALSE),                /* pcrel_offset */
399    
400      /* The lower 16 bits of the GOT offset for the address of the
401         canonical descriptor of a function.  */
402      HOWTO (R_FRV_FUNCDESC_GOTOFFLO, /* type */
403             0,                     /* rightshift */
404             2,                     /* size (0 = byte, 1 = short, 2 = long) */
405             16,                    /* bitsize */
406             FALSE,                 /* pc_relative */
407             0,                     /* bitpos */
408             complain_overflow_dont, /* complain_on_overflow */
409             bfd_elf_generic_reloc, /* special_function */
410             "R_FRV_FUNCDESC_GOTOFFLO", /* name */
411             FALSE,                 /* partial_inplace */
412             0xffff,                /* src_mask */
413             0xffff,                /* dst_mask */
414             FALSE),                /* pcrel_offset */
415    
416      /* A 12-bit signed operand with the GOT offset for the address of
417         the symbol.  */
418      HOWTO (R_FRV_GOTOFF12,        /* type */
419             0,                     /* rightshift */
420             2,                     /* size (0 = byte, 1 = short, 2 = long) */
421             12,                    /* bitsize */
422             FALSE,                 /* pc_relative */
423             0,                     /* bitpos */
424             complain_overflow_signed, /* complain_on_overflow */
425             bfd_elf_generic_reloc, /* special_function */
426             "R_FRV_GOTOFF12",      /* name */
427             FALSE,                 /* partial_inplace */
428             0xfff,                 /* src_mask */
429             0xfff,                 /* dst_mask */
430             FALSE),                /* pcrel_offset */
431    
432      /* The upper 16 bits of the GOT offset for the address of the
433         symbol.  */
434      HOWTO (R_FRV_GOTOFFHI,        /* type */
435             0,                     /* rightshift */
436             2,                     /* size (0 = byte, 1 = short, 2 = long) */
437             16,                    /* bitsize */
438             FALSE,                 /* pc_relative */
439             0,                     /* bitpos */
440             complain_overflow_dont, /* complain_on_overflow */
441             bfd_elf_generic_reloc, /* special_function */
442             "R_FRV_GOTOFFHI",      /* name */
443             FALSE,                 /* partial_inplace */
444             0xffff,                /* src_mask */
445             0xffff,                /* dst_mask */
446             FALSE),                /* pcrel_offset */
447    
448      /* The lower 16 bits of the GOT offset for the address of the
449         symbol.  */
450      HOWTO (R_FRV_GOTOFFLO,        /* type */
451             0,                     /* rightshift */
452             2,                     /* size (0 = byte, 1 = short, 2 = long) */
453             16,                    /* bitsize */
454             FALSE,                 /* pc_relative */
455             0,                     /* bitpos */
456             complain_overflow_dont, /* complain_on_overflow */
457             bfd_elf_generic_reloc, /* special_function */
458             "R_FRV_GOTOFFLO",      /* name */
459             FALSE,                 /* partial_inplace */
460             0xffff,                /* src_mask */
461             0xffff,                /* dst_mask */
462             FALSE),                /* pcrel_offset */
463    
464      /* A 24-bit pc-relative relocation referencing the TLS PLT entry for
465         a thread-local symbol.  If the symbol number is 0, it refers to
466         the module.  */
467      HOWTO (R_FRV_GETTLSOFF,       /* type */
468             2,                     /* rightshift */
469             2,                     /* size (0 = byte, 1 = short, 2 = long) */
470             26,                    /* bitsize */
471             TRUE,                  /* pc_relative */
472             0,                     /* bitpos */
473             complain_overflow_bitfield, /* complain_on_overflow */
474             bfd_elf_generic_reloc, /* special_function */
475             "R_FRV_GETTLSOFF",     /* name */
476             FALSE,                 /* partial_inplace */
477             0x7e03ffff,            /* src_mask */
478             0x7e03ffff,            /* dst_mask */
479             TRUE),                 /* pcrel_offset */
480    
481      /* A 64-bit TLS descriptor for a symbol.  This relocation is only
482         valid as a REL, dynamic relocation.  */
483      HOWTO (R_FRV_TLSDESC_VALUE,   /* type */
484             0,                     /* rightshift */
485             2,                     /* size (0 = byte, 1 = short, 2 = long) */
486             64,                    /* bitsize */
487             FALSE,                 /* pc_relative */
488             0,                     /* bitpos */
489             complain_overflow_bitfield, /* complain_on_overflow */
490             bfd_elf_generic_reloc, /* special_function */
491             "R_FRV_TLSDESC_VALUE", /* name */
492             FALSE,                 /* partial_inplace */
493             0xffffffff,            /* src_mask */
494             0xffffffff,            /* dst_mask */
495             FALSE),                /* pcrel_offset */
496    
497      /* A 12-bit signed operand with the GOT offset for the TLS
498         descriptor of the symbol.  */
499      HOWTO (R_FRV_GOTTLSDESC12,    /* type */
500             0,                     /* rightshift */
501             2,                     /* size (0 = byte, 1 = short, 2 = long) */
502             12,                    /* bitsize */
503             FALSE,                 /* pc_relative */
504             0,                     /* bitpos */
505             complain_overflow_signed, /* complain_on_overflow */
506             bfd_elf_generic_reloc, /* special_function */
507             "R_FRV_GOTTLSDESC12",  /* name */
508             FALSE,                 /* partial_inplace */
509             0xfff,                 /* src_mask */
510             0xfff,                 /* dst_mask */
511             FALSE),                /* pcrel_offset */
512    
513      /* The upper 16 bits of the GOT offset for the TLS descriptor of the
514         symbol.  */
515      HOWTO (R_FRV_GOTTLSDESCHI,    /* type */
516             0,                     /* rightshift */
517             2,                     /* size (0 = byte, 1 = short, 2 = long) */
518             16,                    /* bitsize */
519             FALSE,                 /* pc_relative */
520             0,                     /* bitpos */
521             complain_overflow_dont, /* complain_on_overflow */
522             bfd_elf_generic_reloc, /* special_function */
523             "R_FRV_GOTTLSDESCHI",  /* name */
524             FALSE,                 /* partial_inplace */
525             0xffff,                /* src_mask */
526             0xffff,                /* dst_mask */
527             FALSE),                /* pcrel_offset */
528    
529      /* The lower 16 bits of the GOT offset for the TLS descriptor of the
530         symbol.  */
531      HOWTO (R_FRV_GOTTLSDESCLO,    /* type */
532             0,                     /* rightshift */
533             2,                     /* size (0 = byte, 1 = short, 2 = long) */
534             16,                    /* bitsize */
535             FALSE,                 /* pc_relative */
536             0,                     /* bitpos */
537             complain_overflow_dont, /* complain_on_overflow */
538             bfd_elf_generic_reloc, /* special_function */
539             "R_FRV_GOTTLSDESCLO",  /* name */
540             FALSE,                 /* partial_inplace */
541             0xffff,                /* src_mask */
542             0xffff,                /* dst_mask */
543             FALSE),                /* pcrel_offset */
544    
545      /* A 12-bit signed operand with the offset from the module base
546         address to the thread-local symbol address.  */
547      HOWTO (R_FRV_TLSMOFF12,        /* type */
548             0,                     /* rightshift */
549             2,                     /* size (0 = byte, 1 = short, 2 = long) */
550             12,                    /* bitsize */
551             FALSE,                 /* pc_relative */
552             0,                     /* bitpos */
553             complain_overflow_signed, /* complain_on_overflow */
554             bfd_elf_generic_reloc, /* special_function */
555             "R_FRV_TLSMOFF12",     /* name */
556             FALSE,                 /* partial_inplace */
557             0xfff,                 /* src_mask */
558             0xfff,                 /* dst_mask */
559             FALSE),                /* pcrel_offset */
560    
561      /* The upper 16 bits of the offset from the module base address to
562         the thread-local symbol address.  */
563      HOWTO (R_FRV_TLSMOFFHI,        /* type */
564             0,                     /* rightshift */
565             2,                     /* size (0 = byte, 1 = short, 2 = long) */
566             16,                    /* bitsize */
567             FALSE,                 /* pc_relative */
568             0,                     /* bitpos */
569             complain_overflow_dont, /* complain_on_overflow */
570             bfd_elf_generic_reloc, /* special_function */
571             "R_FRV_TLSMOFFHI",     /* name */
572             FALSE,                 /* partial_inplace */
573             0xffff,                /* src_mask */
574             0xffff,                /* dst_mask */
575             FALSE),                /* pcrel_offset */
576    
577      /* The lower 16 bits of the offset from the module base address to
578         the thread-local symbol address.  */
579      HOWTO (R_FRV_TLSMOFFLO,       /* type */
580             0,                     /* rightshift */
581             2,                     /* size (0 = byte, 1 = short, 2 = long) */
582             16,                    /* bitsize */
583             FALSE,                 /* pc_relative */
584             0,                     /* bitpos */
585             complain_overflow_dont, /* complain_on_overflow */
586             bfd_elf_generic_reloc, /* special_function */
587             "R_FRV_TLSMOFFLO",     /* name */
588             FALSE,                 /* partial_inplace */
589             0xffff,                /* src_mask */
590             0xffff,                /* dst_mask */
591             FALSE),                /* pcrel_offset */
592    
593      /* A 12-bit signed operand with the GOT offset for the TLSOFF entry
594         for a symbol.  */
595      HOWTO (R_FRV_GOTTLSOFF12,        /* type */
596             0,                     /* rightshift */
597             2,                     /* size (0 = byte, 1 = short, 2 = long) */
598             12,                    /* bitsize */
599             FALSE,                 /* pc_relative */
600             0,                     /* bitpos */
601             complain_overflow_signed, /* complain_on_overflow */
602             bfd_elf_generic_reloc, /* special_function */
603             "R_FRV_GOTTLSOFF12",   /* name */
604             FALSE,                 /* partial_inplace */
605             0xfff,                 /* src_mask */
606             0xfff,                 /* dst_mask */
607             FALSE),                /* pcrel_offset */
608    
609      /* The upper 16 bits of the GOT offset for the TLSOFF entry for a
610         symbol.  */
611      HOWTO (R_FRV_GOTTLSOFFHI,        /* type */
612             0,                     /* rightshift */
613             2,                     /* size (0 = byte, 1 = short, 2 = long) */
614             16,                    /* bitsize */
615             FALSE,                 /* pc_relative */
616             0,                     /* bitpos */
617             complain_overflow_dont, /* complain_on_overflow */
618             bfd_elf_generic_reloc, /* special_function */
619             "R_FRV_GOTTLSOFFHI",   /* name */
620             FALSE,                 /* partial_inplace */
621             0xffff,                /* src_mask */
622             0xffff,                /* dst_mask */
623             FALSE),                /* pcrel_offset */
624    
625      /* The lower 16 bits of the GOT offset for the TLSOFF entry for a
626         symbol.  */
627      HOWTO (R_FRV_GOTTLSOFFLO,     /* type */
628             0,                     /* rightshift */
629             2,                     /* size (0 = byte, 1 = short, 2 = long) */
630             16,                    /* bitsize */
631             FALSE,                 /* pc_relative */
632             0,                     /* bitpos */
633             complain_overflow_dont, /* complain_on_overflow */
634             bfd_elf_generic_reloc, /* special_function */
635             "R_FRV_GOTTLSOFFLO",   /* name */
636             FALSE,                 /* partial_inplace */
637             0xffff,                /* src_mask */
638             0xffff,                /* dst_mask */
639             FALSE),                /* pcrel_offset */
640    
641      /* The 32-bit offset from the thread pointer (not the module base
642         address) to a thread-local symbol.  */
643      HOWTO (R_FRV_TLSOFF,          /* type */
644             0,                     /* rightshift */
645             2,                     /* size (0 = byte, 1 = short, 2 = long) */
646             32,                    /* bitsize */
647             FALSE,                 /* pc_relative */
648             0,                     /* bitpos */
649             complain_overflow_dont, /* complain_on_overflow */
650             bfd_elf_generic_reloc, /* special_function */
651             "R_FRV_TLSOFF",        /* name */
652             FALSE,                 /* partial_inplace */
653             0xffffffff,            /* src_mask */
654             0xffffffff,            /* dst_mask */
655             FALSE),                /* pcrel_offset */
656    
657      /* An annotation for linker relaxation, that denotes the
658         symbol+addend whose TLS descriptor is referenced by the sum of
659         the two input registers of an ldd instruction.  */
660      HOWTO (R_FRV_TLSDESC_RELAX,   /* type */
661             0,                     /* rightshift */
662             2,                     /* size (0 = byte, 1 = short, 2 = long) */
663             0,                     /* bitsize */
664             FALSE,                 /* pc_relative */
665             0,                     /* bitpos */
666             complain_overflow_dont, /* complain_on_overflow */
667             bfd_elf_generic_reloc, /* special_function */
668             "R_FRV_TLSDESC_RELAX", /* name */
669             FALSE,                 /* partial_inplace */
670             0,                     /* src_mask */
671             0,                     /* dst_mask */
672             FALSE),                /* pcrel_offset */
673    
674      /* An annotation for linker relaxation, that denotes the
675         symbol+addend whose TLS resolver entry point is given by the sum
676         of the two register operands of an calll instruction.  */
677      HOWTO (R_FRV_GETTLSOFF_RELAX, /* type */
678             0,                     /* rightshift */
679             2,                     /* size (0 = byte, 1 = short, 2 = long) */
680             0,                     /* bitsize */
681             FALSE,                 /* pc_relative */
682             0,                     /* bitpos */
683             complain_overflow_dont, /* complain_on_overflow */
684             bfd_elf_generic_reloc, /* special_function */
685             "R_FRV_GETTLSOFF_RELAX", /* name */
686             FALSE,                 /* partial_inplace */
687             0,                     /* src_mask */
688             0,                     /* dst_mask */
689             FALSE),                /* pcrel_offset */
690    
691      /* An annotation for linker relaxation, that denotes the
692         symbol+addend whose TLS offset GOT entry is given by the sum of
693         the two input registers of an ld instruction.  */
694      HOWTO (R_FRV_TLSOFF_RELAX,    /* type */
695             0,                     /* rightshift */
696             2,                     /* size (0 = byte, 1 = short, 2 = long) */
697             0,                     /* bitsize */
698             FALSE,                 /* pc_relative */
699             0,                     /* bitpos */
700             complain_overflow_bitfield, /* complain_on_overflow */
701             bfd_elf_generic_reloc, /* special_function */
702             "R_FRV_TLSOFF_RELAX",  /* name */
703             FALSE,                 /* partial_inplace */
704             0,                     /* src_mask */
705             0,                     /* dst_mask */
706             FALSE),                /* pcrel_offset */
707    
708      /* A 32-bit offset from the module base address to
709         the thread-local symbol address.  */
710      HOWTO (R_FRV_TLSMOFF, /* type */
711             0,                     /* rightshift */
712             2,                     /* size (0 = byte, 1 = short, 2 = long) */
713             32,                    /* bitsize */
714             FALSE,                 /* pc_relative */
715             0,                     /* bitpos */
716             complain_overflow_dont, /* complain_on_overflow */
717             bfd_elf_generic_reloc, /* special_function */
718             "R_FRV_TLSMOFF",       /* name */
719             FALSE,                 /* partial_inplace */
720             0xffffffff,            /* src_mask */
721             0xffffffff,            /* dst_mask */
722             FALSE),                /* pcrel_offset */
723  };  };
724    
725  /* GNU extension to record C++ vtable hierarchy.  */  /* GNU extension to record C++ vtable hierarchy.  */
# Line 228  static reloc_howto_type elf32_frv_vtinhe Line 728  static reloc_howto_type elf32_frv_vtinhe
728           0,                     /* rightshift */           0,                     /* rightshift */
729           2,                     /* size (0 = byte, 1 = short, 2 = long) */           2,                     /* size (0 = byte, 1 = short, 2 = long) */
730           0,                     /* bitsize */           0,                     /* bitsize */
731           false,                 /* pc_relative */           FALSE,                 /* pc_relative */
732           0,                     /* bitpos */           0,                     /* bitpos */
733           complain_overflow_dont, /* complain_on_overflow */           complain_overflow_dont, /* complain_on_overflow */
734           NULL,                  /* special_function */           NULL,                  /* special_function */
735           "R_FRV_GNU_VTINHERIT", /* name */           "R_FRV_GNU_VTINHERIT", /* name */
736           false,                 /* partial_inplace */           FALSE,                 /* partial_inplace */
737           0,                     /* src_mask */           0,                     /* src_mask */
738           0,                     /* dst_mask */           0,                     /* dst_mask */
739           false);                /* pcrel_offset */           FALSE);                /* pcrel_offset */
740    
741    /* GNU extension to record C++ vtable member usage.  */    /* GNU extension to record C++ vtable member usage.  */
742  static reloc_howto_type elf32_frv_vtentry_howto =  static reloc_howto_type elf32_frv_vtentry_howto =
# Line 244  static reloc_howto_type elf32_frv_vtentr Line 744  static reloc_howto_type elf32_frv_vtentr
744           0,                     /* rightshift */           0,                     /* rightshift */
745           2,                     /* size (0 = byte, 1 = short, 2 = long) */           2,                     /* size (0 = byte, 1 = short, 2 = long) */
746           0,                     /* bitsize */           0,                     /* bitsize */
747           false,                 /* pc_relative */           FALSE,                 /* pc_relative */
748           0,                     /* bitpos */           0,                     /* bitpos */
749           complain_overflow_dont, /* complain_on_overflow */           complain_overflow_dont, /* complain_on_overflow */
750           _bfd_elf_rel_vtable_reloc_fn,  /* special_function */           _bfd_elf_rel_vtable_reloc_fn,  /* special_function */
751           "R_FRV_GNU_VTENTRY",   /* name */           "R_FRV_GNU_VTENTRY",   /* name */
752           false,                 /* partial_inplace */           FALSE,                 /* partial_inplace */
753           0,                     /* src_mask */           0,                     /* src_mask */
754           0,                     /* dst_mask */           0,                     /* dst_mask */
755           false);                /* pcrel_offset */           FALSE);                /* pcrel_offset */
756    
757    /* The following 3 relocations are REL.  The only difference to the
758       entries in the table above are that partial_inplace is TRUE.  */
759    static reloc_howto_type elf32_frv_rel_32_howto =
760      HOWTO (R_FRV_32,              /* type */
761             0,                     /* rightshift */
762             2,                     /* size (0 = byte, 1 = short, 2 = long) */
763             32,                    /* bitsize */
764             FALSE,                 /* pc_relative */
765             0,                     /* bitpos */
766             complain_overflow_bitfield, /* complain_on_overflow */
767             bfd_elf_generic_reloc, /* special_function */
768             "R_FRV_32",            /* name */
769             TRUE,                  /* partial_inplace */
770             0xffffffff,            /* src_mask */
771             0xffffffff,            /* dst_mask */
772             FALSE);                /* pcrel_offset */
773    
774    static reloc_howto_type elf32_frv_rel_funcdesc_howto =
775      HOWTO (R_FRV_FUNCDESC,        /* type */
776             0,                     /* rightshift */
777             2,                     /* size (0 = byte, 1 = short, 2 = long) */
778             32,                    /* bitsize */
779             FALSE,                 /* pc_relative */
780             0,                     /* bitpos */
781             complain_overflow_bitfield, /* complain_on_overflow */
782             bfd_elf_generic_reloc, /* special_function */
783             "R_FRV_FUNCDESC",      /* name */
784             TRUE,                  /* partial_inplace */
785             0xffffffff,            /* src_mask */
786             0xffffffff,            /* dst_mask */
787             FALSE);                /* pcrel_offset */
788    
789    static reloc_howto_type elf32_frv_rel_funcdesc_value_howto =
790      HOWTO (R_FRV_FUNCDESC_VALUE,  /* type */
791             0,                     /* rightshift */
792             2,                     /* size (0 = byte, 1 = short, 2 = long) */
793             64,                    /* bitsize */
794             FALSE,                 /* pc_relative */
795             0,                     /* bitpos */
796             complain_overflow_bitfield, /* complain_on_overflow */
797             bfd_elf_generic_reloc, /* special_function */
798             "R_FRV_FUNCDESC_VALUE", /* name */
799             TRUE,                  /* partial_inplace */
800             0xffffffff,            /* src_mask */
801             0xffffffff,            /* dst_mask */
802             FALSE);                /* pcrel_offset */
803    
804    static reloc_howto_type elf32_frv_rel_tlsdesc_value_howto =
805      /* A 64-bit TLS descriptor for a symbol.  The first word resolves to
806         an entry point, and the second resolves to a special argument.
807         If the symbol turns out to be in static TLS, the entry point is a
808         return instruction, and the special argument is the TLS offset
809         for the symbol.  If it's in dynamic TLS, the entry point is a TLS
810         offset resolver, and the special argument is a pointer to a data
811         structure allocated by the dynamic loader, containing the GOT
812         address for the offset resolver, the module id, the offset within
813         the module, and anything else the TLS offset resolver might need
814         to determine the TLS offset for the symbol in the running
815         thread.  */
816      HOWTO (R_FRV_TLSDESC_VALUE,   /* type */
817             0,                     /* rightshift */
818             2,                     /* size (0 = byte, 1 = short, 2 = long) */
819             64,                    /* bitsize */
820             FALSE,                 /* pc_relative */
821             0,                     /* bitpos */
822             complain_overflow_bitfield, /* complain_on_overflow */
823             bfd_elf_generic_reloc, /* special_function */
824             "R_FRV_TLSDESC_VALUE", /* name */
825             TRUE,                  /* partial_inplace */
826             0xffffffff,            /* src_mask */
827             0xffffffff,            /* dst_mask */
828             FALSE);                /* pcrel_offset */
829    
830    static reloc_howto_type elf32_frv_rel_tlsoff_howto =
831      /* The 32-bit offset from the thread pointer (not the module base
832         address) to a thread-local symbol.  */
833      HOWTO (R_FRV_TLSOFF,          /* type */
834             0,                     /* rightshift */
835             2,                     /* size (0 = byte, 1 = short, 2 = long) */
836             32,                    /* bitsize */
837             FALSE,                 /* pc_relative */
838             0,                     /* bitpos */
839             complain_overflow_bitfield, /* complain_on_overflow */
840             bfd_elf_generic_reloc, /* special_function */
841             "R_FRV_TLSOFF",        /* name */
842             TRUE,                  /* partial_inplace */
843             0xffffffff,            /* src_mask */
844             0xffffffff,            /* dst_mask */
845             FALSE);                /* pcrel_offset */
846    
847    
848    
849  /* Map BFD reloc types to FRV ELF reloc types.  */  extern const bfd_target bfd_elf32_frvfdpic_vec;
850  #if 0  #define IS_FDPIC(bfd) ((bfd)->xvec == &bfd_elf32_frvfdpic_vec)
851  struct frv_reloc_map  
852    /* An extension of the elf hash table data structure, containing some
853       additional FRV-specific data.  */
854    struct frvfdpic_elf_link_hash_table
855  {  {
856    unsigned int bfd_reloc_val;    struct elf_link_hash_table elf;
857    unsigned int frv_reloc_val;  
858      /* A pointer to the .got section.  */
859      asection *sgot;
860      /* A pointer to the .rel.got section.  */
861      asection *sgotrel;
862      /* A pointer to the .rofixup section.  */
863      asection *sgotfixup;
864      /* A pointer to the .plt section.  */
865      asection *splt;
866      /* A pointer to the .rel.plt section.  */
867      asection *spltrel;
868      /* GOT base offset.  */
869      bfd_vma got0;
870      /* Location of the first non-lazy PLT entry, i.e., the number of
871         bytes taken by lazy PLT entries.  If locally-bound TLS
872         descriptors require a ret instruction, it will be placed at this
873         offset.  */
874      bfd_vma plt0;
875      /* A hash table holding information about which symbols were
876         referenced with which PIC-related relocations.  */
877      struct htab *relocs_info;
878      /* Summary reloc information collected by
879         _frvfdpic_count_got_plt_entries.  */
880      struct _frvfdpic_dynamic_got_info *g;
881  };  };
882    
883  static const struct frv_reloc_map frv_reloc_map [] =  /* Get the FRV ELF linker hash table from a link_info structure.  */
884    
885    #define frvfdpic_hash_table(info) \
886      ((struct frvfdpic_elf_link_hash_table *) ((info)->hash))
887    
888    #define frvfdpic_got_section(info) \
889      (frvfdpic_hash_table (info)->sgot)
890    #define frvfdpic_gotrel_section(info) \
891      (frvfdpic_hash_table (info)->sgotrel)
892    #define frvfdpic_gotfixup_section(info) \
893      (frvfdpic_hash_table (info)->sgotfixup)
894    #define frvfdpic_plt_section(info) \
895      (frvfdpic_hash_table (info)->splt)
896    #define frvfdpic_pltrel_section(info) \
897      (frvfdpic_hash_table (info)->spltrel)
898    #define frvfdpic_relocs_info(info) \
899      (frvfdpic_hash_table (info)->relocs_info)
900    #define frvfdpic_got_initial_offset(info) \
901      (frvfdpic_hash_table (info)->got0)
902    #define frvfdpic_plt_initial_offset(info) \
903      (frvfdpic_hash_table (info)->plt0)
904    #define frvfdpic_dynamic_got_plt_info(info) \
905      (frvfdpic_hash_table (info)->g)
906    
907    /* Currently it's the same, but if some day we have a reason to change
908       it, we'd better be using a different macro.
909    
910       FIXME: if there's any TLS PLT entry that uses local-exec or
911       initial-exec models, we could use the ret at the end of any of them
912       instead of adding one more.  */
913    #define frvfdpic_plt_tls_ret_offset(info) \
914      (frvfdpic_plt_initial_offset (info))
915    
916    /* The name of the dynamic interpreter.  This is put in the .interp
917       section.  */
918    
919    #define ELF_DYNAMIC_INTERPRETER "/lib/ld.so.1"
920    
921    #define DEFAULT_STACK_SIZE 0x20000
922    
923    /* This structure is used to collect the number of entries present in
924       each addressable range of the got.  */
925    struct _frvfdpic_dynamic_got_info
926  {  {
927    { BFD_RELOC_NONE,           R_FRV_NONE },    /* Several bits of information about the current link.  */
928    { BFD_RELOC_32,             R_FRV_32 },    struct bfd_link_info *info;
929    { BFD_RELOC_FRV_LABEL16,    R_FRV_LABEL16 },    /* Total GOT size needed for GOT entries within the 12-, 16- or 32-bit
930    { BFD_RELOC_FRV_LABEL24,    R_FRV_LABEL24 },       ranges.  */
931    { BFD_RELOC_FRV_LO16,       R_FRV_LO16 },    bfd_vma got12, gotlos, gothilo;
932    { BFD_RELOC_FRV_HI16,       R_FRV_HI16 },    /* Total GOT size needed for function descriptor entries within the 12-,
933    { BFD_RELOC_FRV_GPREL12,    R_FRV_GPREL12 },       16- or 32-bit ranges.  */
934    { BFD_RELOC_FRV_GPRELU12,   R_FRV_GPRELU12 },    bfd_vma fd12, fdlos, fdhilo;
935    { BFD_RELOC_FRV_GPREL32,    R_FRV_GPREL32 },    /* Total GOT size needed by function descriptor entries referenced
936    { BFD_RELOC_FRV_GPRELHI,    R_FRV_GPRELHI },       in PLT entries, that would be profitable to place in offsets
937    { BFD_RELOC_FRV_GPRELLO,    R_FRV_GPRELLO },       close to the PIC register.  */
938    { BFD_RELOC_VTABLE_INHERIT, R_FRV_GNU_VTINHERIT },    bfd_vma fdplt;
939    { BFD_RELOC_VTABLE_ENTRY,   R_FRV_GNU_VTENTRY },    /* Total PLT size needed by lazy PLT entries.  */
940      bfd_vma lzplt;
941      /* Total GOT size needed for TLS descriptor entries within the 12-,
942         16- or 32-bit ranges.  */
943      bfd_vma tlsd12, tlsdlos, tlsdhilo;
944      /* Total GOT size needed by TLS descriptors referenced in PLT
945         entries, that would be profitable to place in offers close to the
946         PIC register.  */
947      bfd_vma tlsdplt;
948      /* Total PLT size needed by TLS lazy PLT entries.  */
949      bfd_vma tlslzplt;
950      /* Number of relocations carried over from input object files.  */
951      unsigned long relocs;
952      /* Number of fixups introduced by relocations in input object files.  */
953      unsigned long fixups;
954      /* The number of fixups that reference the ret instruction added to
955         the PLT for locally-resolved TLS descriptors.  */
956      unsigned long tls_ret_refs;
957  };  };
958  #endif  
959    /* This structure is used to assign offsets to got entries, function
960       descriptors, plt entries and lazy plt entries.  */
961    
962    struct _frvfdpic_dynamic_got_plt_info
963    {
964      /* Summary information collected with _frvfdpic_count_got_plt_entries.  */
965      struct _frvfdpic_dynamic_got_info g;
966    
967      /* For each addressable range, we record a MAX (positive) and MIN
968         (negative) value.  CUR is used to assign got entries, and it's
969         incremented from an initial positive value to MAX, then from MIN
970         to FDCUR (unless FDCUR wraps around first).  FDCUR is used to
971         assign function descriptors, and it's decreased from an initial
972         non-positive value to MIN, then from MAX down to CUR (unless CUR
973         wraps around first).  All of MIN, MAX, CUR and FDCUR always point
974         to even words.  ODD, if non-zero, indicates an odd word to be
975         used for the next got entry, otherwise CUR is used and
976         incremented by a pair of words, wrapping around when it reaches
977         MAX.  FDCUR is decremented (and wrapped) before the next function
978         descriptor is chosen.  FDPLT indicates the number of remaining
979         slots that can be used for function descriptors used only by PLT
980         entries.
981    
982         TMAX, TMIN and TCUR are used to assign TLS descriptors.  TCUR
983         starts as MAX, and grows up to TMAX, then wraps around to TMIN
984         and grows up to MIN.  TLSDPLT indicates the number of remaining
985         slots that can be used for TLS descriptors used only by TLS PLT
986         entries.  */
987      struct _frvfdpic_dynamic_got_alloc_data
988      {
989        bfd_signed_vma max, cur, odd, fdcur, min;
990        bfd_signed_vma tmax, tcur, tmin;
991        bfd_vma fdplt, tlsdplt;
992      } got12, gotlos, gothilo;
993    };
994    
995    /* Create an FRV ELF linker hash table.  */
996    
997    static struct bfd_link_hash_table *
998    frvfdpic_elf_link_hash_table_create (bfd *abfd)
999    {
1000      struct frvfdpic_elf_link_hash_table *ret;
1001      bfd_size_type amt = sizeof (struct frvfdpic_elf_link_hash_table);
1002    
1003      ret = bfd_zalloc (abfd, amt);
1004      if (ret == NULL)
1005        return NULL;
1006    
1007      if (! _bfd_elf_link_hash_table_init (&ret->elf, abfd,
1008                                           _bfd_elf_link_hash_newfunc))
1009        {
1010          free (ret);
1011          return NULL;
1012        }
1013    
1014      return &ret->elf.root;
1015    }
1016    
1017    /* Decide whether a reference to a symbol can be resolved locally or
1018       not.  If the symbol is protected, we want the local address, but
1019       its function descriptor must be assigned by the dynamic linker.  */
1020    #define FRVFDPIC_SYM_LOCAL(INFO, H) \
1021      (_bfd_elf_symbol_refs_local_p ((H), (INFO), 1) \
1022       || ! elf_hash_table (INFO)->dynamic_sections_created)
1023    #define FRVFDPIC_FUNCDESC_LOCAL(INFO, H) \
1024      ((H)->dynindx == -1 || ! elf_hash_table (INFO)->dynamic_sections_created)
1025    
1026    /* This structure collects information on what kind of GOT, PLT or
1027       function descriptors are required by relocations that reference a
1028       certain symbol.  */
1029    struct frvfdpic_relocs_info
1030    {
1031      /* The index of the symbol, as stored in the relocation r_info, if
1032         we have a local symbol; -1 otherwise.  */
1033      long symndx;
1034      union
1035      {
1036        /* The input bfd in which the symbol is defined, if it's a local
1037           symbol.  */
1038        bfd *abfd;
1039        /* If symndx == -1, the hash table entry corresponding to a global
1040           symbol (even if it turns out to bind locally, in which case it
1041           should ideally be replaced with section's symndx + addend).  */
1042        struct elf_link_hash_entry *h;
1043      } d;
1044      /* The addend of the relocation that references the symbol.  */
1045      bfd_vma addend;
1046    
1047      /* The fields above are used to identify an entry.  The fields below
1048         contain information on how an entry is used and, later on, which
1049         locations it was assigned.  */
1050      /* The following 3 fields record whether the symbol+addend above was
1051         ever referenced with a GOT relocation.  The 12 suffix indicates a
1052         GOT12 relocation; los is used for GOTLO relocations that are not
1053         matched by a GOTHI relocation; hilo is used for GOTLO/GOTHI
1054         pairs.  */
1055      unsigned got12:1;
1056      unsigned gotlos:1;
1057      unsigned gothilo:1;
1058      /* Whether a FUNCDESC relocation references symbol+addend.  */
1059      unsigned fd:1;
1060      /* Whether a FUNCDESC_GOT relocation references symbol+addend.  */
1061      unsigned fdgot12:1;
1062      unsigned fdgotlos:1;
1063      unsigned fdgothilo:1;
1064      /* Whether a FUNCDESC_GOTOFF relocation references symbol+addend.  */
1065      unsigned fdgoff12:1;
1066      unsigned fdgofflos:1;
1067      unsigned fdgoffhilo:1;
1068      /* Whether a GETTLSOFF relocation references symbol+addend.  */
1069      unsigned tlsplt:1;
1070      /* FIXME: we should probably add tlspltdesc, tlspltoff and
1071         tlspltimm, to tell what kind of TLS PLT entry we're generating.
1072         We might instead just pre-compute flags telling whether the
1073         object is suitable for local exec, initial exec or general
1074         dynamic addressing, and use that all over the place.  We could
1075         also try to do a better job of merging TLSOFF and TLSDESC entries
1076         in main executables, but perhaps we can get rid of TLSDESC
1077         entirely in them instead.  */
1078      /* Whether a GOTTLSDESC relocation references symbol+addend.  */
1079      unsigned tlsdesc12:1;
1080      unsigned tlsdesclos:1;
1081      unsigned tlsdeschilo:1;
1082      /* Whether a GOTTLSOFF relocation references symbol+addend.  */
1083      unsigned tlsoff12:1;
1084      unsigned tlsofflos:1;
1085      unsigned tlsoffhilo:1;
1086      /* Whether symbol+addend is referenced with GOTOFF12, GOTOFFLO or
1087         GOTOFFHI relocations.  The addend doesn't really matter, since we
1088         envision that this will only be used to check whether the symbol
1089         is mapped to the same segment as the got.  */
1090      unsigned gotoff:1;
1091      /* Whether symbol+addend is referenced by a LABEL24 relocation.  */
1092      unsigned call:1;
1093      /* Whether symbol+addend is referenced by a 32 or FUNCDESC_VALUE
1094         relocation.  */
1095      unsigned sym:1;
1096      /* Whether we need a PLT entry for a symbol.  Should be implied by
1097         something like:
1098         (call && symndx == -1 && ! FRVFDPIC_SYM_LOCAL (info, d.h))  */
1099      unsigned plt:1;
1100      /* Whether a function descriptor should be created in this link unit
1101         for symbol+addend.  Should be implied by something like:
1102         (plt || fdgotoff12 || fdgotofflos || fdgotofflohi
1103          || ((fd || fdgot12 || fdgotlos || fdgothilo)
1104              && (symndx != -1 || FRVFDPIC_FUNCDESC_LOCAL (info, d.h))))  */
1105      unsigned privfd:1;
1106      /* Whether a lazy PLT entry is needed for this symbol+addend.
1107         Should be implied by something like:
1108         (privfd && symndx == -1 && ! FRVFDPIC_SYM_LOCAL (info, d.h)
1109          && ! (info->flags & DF_BIND_NOW))  */
1110      unsigned lazyplt:1;
1111      /* Whether we've already emitted GOT relocations and PLT entries as
1112         needed for this symbol.  */
1113      unsigned done:1;
1114    
1115      /* The number of R_FRV_32, R_FRV_FUNCDESC, R_FRV_FUNCDESC_VALUE and
1116         R_FRV_TLSDESC_VALUE, R_FRV_TLSOFF relocations referencing
1117         symbol+addend.  */
1118      unsigned relocs32, relocsfd, relocsfdv, relocstlsd, relocstlsoff;
1119    
1120      /* The number of .rofixups entries and dynamic relocations allocated
1121         for this symbol, minus any that might have already been used.  */
1122      unsigned fixups, dynrelocs;
1123    
1124      /* The offsets of the GOT entries assigned to symbol+addend, to the
1125         function descriptor's address, and to a function descriptor,
1126         respectively.  Should be zero if unassigned.  The offsets are
1127         counted from the value that will be assigned to the PIC register,
1128         not from the beginning of the .got section.  */
1129      bfd_signed_vma got_entry, fdgot_entry, fd_entry;
1130      /* The offsets of the PLT entries assigned to symbol+addend,
1131         non-lazy and lazy, respectively.  If unassigned, should be
1132         (bfd_vma)-1.  */
1133      bfd_vma plt_entry, lzplt_entry;
1134      /* The offsets of the GOT entries for TLS offset and TLS descriptor.  */
1135      bfd_signed_vma tlsoff_entry, tlsdesc_entry;
1136      /* The offset of the TLS offset PLT entry.  */
1137      bfd_vma tlsplt_entry;
1138    };
1139    
1140    /* Compute a hash with the key fields of an frvfdpic_relocs_info entry.  */
1141    static hashval_t
1142    frvfdpic_relocs_info_hash (const void *entry_)
1143    {
1144      const struct frvfdpic_relocs_info *entry = entry_;
1145    
1146      return (entry->symndx == -1
1147              ? (long) entry->d.h->root.root.hash
1148              : entry->symndx + (long) entry->d.abfd->id * 257) + entry->addend;
1149    }
1150    
1151    /* Test whether the key fields of two frvfdpic_relocs_info entries are
1152       identical.  */
1153    static int
1154    frvfdpic_relocs_info_eq (const void *entry1, const void *entry2)
1155    {
1156      const struct frvfdpic_relocs_info *e1 = entry1;
1157      const struct frvfdpic_relocs_info *e2 = entry2;
1158    
1159      return e1->symndx == e2->symndx && e1->addend == e2->addend
1160        && (e1->symndx == -1 ? e1->d.h == e2->d.h : e1->d.abfd == e2->d.abfd);
1161    }
1162    
1163    /* Find or create an entry in a hash table HT that matches the key
1164       fields of the given ENTRY.  If it's not found, memory for a new
1165       entry is allocated in ABFD's obstack.  */
1166    static struct frvfdpic_relocs_info *
1167    frvfdpic_relocs_info_find (struct htab *ht,
1168                               bfd *abfd,
1169                               const struct frvfdpic_relocs_info *entry,
1170                               enum insert_option insert)
1171    {
1172      struct frvfdpic_relocs_info **loc =
1173        (struct frvfdpic_relocs_info **) htab_find_slot (ht, entry, insert);
1174    
1175      if (! loc)
1176        return NULL;
1177    
1178      if (*loc)
1179        return *loc;
1180    
1181      *loc = bfd_zalloc (abfd, sizeof (**loc));
1182    
1183      if (! *loc)
1184        return *loc;
1185    
1186      (*loc)->symndx = entry->symndx;
1187      (*loc)->d = entry->d;
1188      (*loc)->addend = entry->addend;
1189      (*loc)->plt_entry = (bfd_vma)-1;
1190      (*loc)->lzplt_entry = (bfd_vma)-1;
1191      (*loc)->tlsplt_entry = (bfd_vma)-1;
1192    
1193      return *loc;
1194    }
1195    
1196    /* Obtain the address of the entry in HT associated with H's symbol +
1197       addend, creating a new entry if none existed.  ABFD is only used
1198       for memory allocation purposes.  */
1199    inline static struct frvfdpic_relocs_info *
1200    frvfdpic_relocs_info_for_global (struct htab *ht,
1201                                     bfd *abfd,
1202                                     struct elf_link_hash_entry *h,
1203                                     bfd_vma addend,
1204                                     enum insert_option insert)
1205    {
1206      struct frvfdpic_relocs_info entry;
1207    
1208      entry.symndx = -1;
1209      entry.d.h = h;
1210      entry.addend = addend;
1211    
1212      return frvfdpic_relocs_info_find (ht, abfd, &entry, insert);
1213    }
1214    
1215    /* Obtain the address of the entry in HT associated with the SYMNDXth
1216       local symbol of the input bfd ABFD, plus the addend, creating a new
1217       entry if none existed.  */
1218    inline static struct frvfdpic_relocs_info *
1219    frvfdpic_relocs_info_for_local (struct htab *ht,
1220                                    bfd *abfd,
1221                                    long symndx,
1222                                    bfd_vma addend,
1223                                    enum insert_option insert)
1224    {
1225      struct frvfdpic_relocs_info entry;
1226    
1227      entry.symndx = symndx;
1228      entry.d.abfd = abfd;
1229      entry.addend = addend;
1230    
1231      return frvfdpic_relocs_info_find (ht, abfd, &entry, insert);
1232    }
1233    
1234    /* Merge fields set by check_relocs() of two entries that end up being
1235       mapped to the same (presumably global) symbol.  */
1236    
1237    inline static void
1238    frvfdpic_pic_merge_early_relocs_info (struct frvfdpic_relocs_info *e2,
1239                                          struct frvfdpic_relocs_info const *e1)
1240    {
1241      e2->got12 |= e1->got12;
1242      e2->gotlos |= e1->gotlos;
1243      e2->gothilo |= e1->gothilo;
1244      e2->fd |= e1->fd;
1245      e2->fdgot12 |= e1->fdgot12;
1246      e2->fdgotlos |= e1->fdgotlos;
1247      e2->fdgothilo |= e1->fdgothilo;
1248      e2->fdgoff12 |= e1->fdgoff12;
1249      e2->fdgofflos |= e1->fdgofflos;
1250      e2->fdgoffhilo |= e1->fdgoffhilo;
1251      e2->tlsplt |= e1->tlsplt;
1252      e2->tlsdesc12 |= e1->tlsdesc12;
1253      e2->tlsdesclos |= e1->tlsdesclos;
1254      e2->tlsdeschilo |= e1->tlsdeschilo;
1255      e2->tlsoff12 |= e1->tlsoff12;
1256      e2->tlsofflos |= e1->tlsofflos;
1257      e2->tlsoffhilo |= e1->tlsoffhilo;
1258      e2->gotoff |= e1->gotoff;
1259      e2->call |= e1->call;
1260      e2->sym |= e1->sym;
1261    }
1262    
1263    /* Every block of 65535 lazy PLT entries shares a single call to the
1264       resolver, inserted in the 32768th lazy PLT entry (i.e., entry #
1265       32767, counting from 0).  All other lazy PLT entries branch to it
1266       in a single instruction.  */
1267    
1268    #define FRVFDPIC_LZPLT_BLOCK_SIZE ((bfd_vma) 8 * 65535 + 4)
1269    #define FRVFDPIC_LZPLT_RESOLV_LOC (8 * 32767)
1270    
1271    /* Add a dynamic relocation to the SRELOC section.  */
1272    
1273    inline static bfd_vma
1274    _frvfdpic_add_dyn_reloc (bfd *output_bfd, asection *sreloc, bfd_vma offset,
1275                             int reloc_type, long dynindx, bfd_vma addend,
1276                             struct frvfdpic_relocs_info *entry)
1277    {
1278      Elf_Internal_Rela outrel;
1279      bfd_vma reloc_offset;
1280    
1281      outrel.r_offset = offset;
1282      outrel.r_info = ELF32_R_INFO (dynindx, reloc_type);
1283      outrel.r_addend = addend;
1284    
1285      reloc_offset = sreloc->reloc_count * sizeof (Elf32_External_Rel);
1286      BFD_ASSERT (reloc_offset < sreloc->size);
1287      bfd_elf32_swap_reloc_out (output_bfd, &outrel,
1288                                sreloc->contents + reloc_offset);
1289      sreloc->reloc_count++;
1290    
1291      /* If the entry's index is zero, this relocation was probably to a
1292         linkonce section that got discarded.  We reserved a dynamic
1293         relocation, but it was for another entry than the one we got at
1294         the time of emitting the relocation.  Unfortunately there's no
1295         simple way for us to catch this situation, since the relocation
1296         is cleared right before calling relocate_section, at which point
1297         we no longer know what the relocation used to point to.  */
1298      if (entry->symndx)
1299        {
1300          BFD_ASSERT (entry->dynrelocs > 0);
1301          entry->dynrelocs--;
1302        }
1303    
1304      return reloc_offset;
1305    }
1306    
1307    /* Add a fixup to the ROFIXUP section.  */
1308    
1309    static bfd_vma
1310    _frvfdpic_add_rofixup (bfd *output_bfd, asection *rofixup, bfd_vma offset,
1311                           struct frvfdpic_relocs_info *entry)
1312    {
1313      bfd_vma fixup_offset;
1314    
1315      if (rofixup->flags & SEC_EXCLUDE)
1316        return -1;
1317    
1318      fixup_offset = rofixup->reloc_count * 4;
1319      if (rofixup->contents)
1320        {
1321          BFD_ASSERT (fixup_offset < rofixup->size);
1322          bfd_put_32 (output_bfd, offset, rofixup->contents + fixup_offset);
1323        }
1324      rofixup->reloc_count++;
1325    
1326      if (entry && entry->symndx)
1327        {
1328          /* See discussion about symndx == 0 in _frvfdpic_add_dyn_reloc
1329             above.  */
1330          BFD_ASSERT (entry->fixups > 0);
1331          entry->fixups--;
1332        }
1333    
1334      return fixup_offset;
1335    }
1336    
1337    /* Find the segment number in which OSEC, and output section, is
1338       located.  */
1339    
1340    static unsigned
1341    _frvfdpic_osec_to_segment (bfd *output_bfd, asection *osec)
1342    {
1343      struct elf_segment_map *m;
1344      Elf_Internal_Phdr *p;
1345    
1346      /* Find the segment that contains the output_section.  */
1347      for (m = elf_tdata (output_bfd)->segment_map,
1348             p = elf_tdata (output_bfd)->phdr;
1349           m != NULL;
1350           m = m->next, p++)
1351        {
1352          int i;
1353    
1354          for (i = m->count - 1; i >= 0; i--)
1355            if (m->sections[i] == osec)
1356              break;
1357    
1358          if (i >= 0)
1359            break;
1360        }
1361    
1362      return p - elf_tdata (output_bfd)->phdr;
1363    }
1364    
1365    inline static bfd_boolean
1366    _frvfdpic_osec_readonly_p (bfd *output_bfd, asection *osec)
1367    {
1368      unsigned seg = _frvfdpic_osec_to_segment (output_bfd, osec);
1369    
1370      return ! (elf_tdata (output_bfd)->phdr[seg].p_flags & PF_W);
1371    }
1372    
1373    #define FRVFDPIC_TLS_BIAS (2048 - 16)
1374    
1375    /* Return the base VMA address which should be subtracted from real addresses
1376       when resolving TLSMOFF relocation.
1377       This is PT_TLS segment p_vaddr, plus the 2048-16 bias.  */
1378    
1379    static bfd_vma
1380    tls_biased_base (struct bfd_link_info *info)
1381    {
1382      /* If tls_sec is NULL, we should have signalled an error already.  */
1383      if (elf_hash_table (info)->tls_sec == NULL)
1384        return FRVFDPIC_TLS_BIAS;
1385      return elf_hash_table (info)->tls_sec->vma + FRVFDPIC_TLS_BIAS;
1386    }
1387    
1388    /* Generate relocations for GOT entries, function descriptors, and
1389       code for PLT and lazy PLT entries.  */
1390    
1391    inline static bfd_boolean
1392    _frvfdpic_emit_got_relocs_plt_entries (struct frvfdpic_relocs_info *entry,
1393                                           bfd *output_bfd,
1394                                           struct bfd_link_info *info,
1395                                           asection *sec,
1396                                           Elf_Internal_Sym *sym,
1397                                           bfd_vma addend)
1398    
1399    {
1400      bfd_vma fd_lazy_rel_offset = (bfd_vma)-1;
1401      int dynindx = -1;
1402    
1403      if (entry->done)
1404        return TRUE;
1405      entry->done = 1;
1406    
1407      if (entry->got_entry || entry->fdgot_entry || entry->fd_entry
1408          || entry->tlsoff_entry || entry->tlsdesc_entry)
1409        {
1410          /* If the symbol is dynamic, consider it for dynamic
1411             relocations, otherwise decay to section + offset.  */
1412          if (entry->symndx == -1 && entry->d.h->dynindx != -1)
1413            dynindx = entry->d.h->dynindx;
1414          else
1415            {
1416              if (sec->output_section
1417                  && ! bfd_is_abs_section (sec->output_section)
1418                  && ! bfd_is_und_section (sec->output_section))
1419                dynindx = elf_section_data (sec->output_section)->dynindx;
1420              else
1421                dynindx = 0;
1422            }
1423        }
1424    
1425      /* Generate relocation for GOT entry pointing to the symbol.  */
1426      if (entry->got_entry)
1427        {
1428          int idx = dynindx;
1429          bfd_vma ad = addend;
1430    
1431          /* If the symbol is dynamic but binds locally, use
1432             section+offset.  */
1433          if (sec && (entry->symndx != -1
1434                      || FRVFDPIC_SYM_LOCAL (info, entry->d.h)))
1435            {
1436              if (entry->symndx == -1)
1437                ad += entry->d.h->root.u.def.value;
1438              else
1439                ad += sym->st_value;
1440              ad += sec->output_offset;
1441              if (sec->output_section && elf_section_data (sec->output_section))
1442                idx = elf_section_data (sec->output_section)->dynindx;
1443              else
1444                idx = 0;
1445            }
1446    
1447          /* If we're linking an executable at a fixed address, we can
1448             omit the dynamic relocation as long as the symbol is local to
1449             this module.  */
1450          if (info->executable && !info->pie
1451              && (entry->symndx != -1
1452                  || FRVFDPIC_SYM_LOCAL (info, entry->d.h)))
1453            {
1454              if (sec)
1455                ad += sec->output_section->vma;
1456              if (entry->symndx != -1
1457                  || entry->d.h->root.type != bfd_link_hash_undefweak)
1458                _frvfdpic_add_rofixup (output_bfd,
1459                                       frvfdpic_gotfixup_section (info),
1460                                       frvfdpic_got_section (info)->output_section
1461                                       ->vma
1462                                       + frvfdpic_got_section (info)->output_offset
1463                                       + frvfdpic_got_initial_offset (info)
1464                                       + entry->got_entry, entry);
1465            }
1466          else
1467            _frvfdpic_add_dyn_reloc (output_bfd, frvfdpic_gotrel_section (info),
1468                                     _bfd_elf_section_offset
1469                                     (output_bfd, info,
1470                                      frvfdpic_got_section (info),
1471                                      frvfdpic_got_initial_offset (info)
1472                                      + entry->got_entry)
1473                                     + frvfdpic_got_section (info)
1474                                     ->output_section->vma
1475                                     + frvfdpic_got_section (info)->output_offset,
1476                                     R_FRV_32, idx, ad, entry);
1477    
1478          bfd_put_32 (output_bfd, ad,
1479                      frvfdpic_got_section (info)->contents
1480                      + frvfdpic_got_initial_offset (info)
1481                      + entry->got_entry);
1482        }
1483    
1484      /* Generate relocation for GOT entry pointing to a canonical
1485         function descriptor.  */
1486      if (entry->fdgot_entry)
1487        {
1488          int reloc, idx;
1489          bfd_vma ad = 0;
1490    
1491          if (! (entry->symndx == -1
1492                 && entry->d.h->root.type == bfd_link_hash_undefweak
1493                 && FRVFDPIC_SYM_LOCAL (info, entry->d.h)))
1494            {
1495              /* If the symbol is dynamic and there may be dynamic symbol
1496                 resolution because we are, or are linked with, a shared
1497                 library, emit a FUNCDESC relocation such that the dynamic
1498                 linker will allocate the function descriptor.  If the
1499                 symbol needs a non-local function descriptor but binds
1500                 locally (e.g., its visibility is protected, emit a
1501                 dynamic relocation decayed to section+offset.  */
1502              if (entry->symndx == -1
1503                  && ! FRVFDPIC_FUNCDESC_LOCAL (info, entry->d.h)
1504                  && FRVFDPIC_SYM_LOCAL (info, entry->d.h)
1505                  && !(info->executable && !info->pie))
1506                {
1507                  reloc = R_FRV_FUNCDESC;
1508                  idx = elf_section_data (entry->d.h->root.u.def.section
1509                                          ->output_section)->dynindx;
1510                  ad = entry->d.h->root.u.def.section->output_offset
1511                    + entry->d.h->root.u.def.value;
1512                }
1513              else if (entry->symndx == -1
1514                       && ! FRVFDPIC_FUNCDESC_LOCAL (info, entry->d.h))
1515                {
1516                  reloc = R_FRV_FUNCDESC;
1517                  idx = dynindx;
1518                  ad = addend;
1519                  if (ad)
1520                    {
1521                      (*info->callbacks->reloc_dangerous)
1522                        (info, _("relocation requires zero addend"),
1523                         elf_hash_table (info)->dynobj,
1524                         frvfdpic_got_section (info),
1525                         entry->fdgot_entry);
1526                      return FALSE;
1527                    }
1528                }
1529              else
1530                {
1531                  /* Otherwise, we know we have a private function descriptor,
1532                     so reference it directly.  */
1533                  if (elf_hash_table (info)->dynamic_sections_created)
1534                    BFD_ASSERT (entry->privfd);
1535                  reloc = R_FRV_32;
1536                  idx = elf_section_data (frvfdpic_got_section (info)
1537                                          ->output_section)->dynindx;
1538                  ad = frvfdpic_got_section (info)->output_offset
1539                    + frvfdpic_got_initial_offset (info) + entry->fd_entry;
1540                }
1541    
1542              /* If there is room for dynamic symbol resolution, emit the
1543                 dynamic relocation.  However, if we're linking an
1544                 executable at a fixed location, we won't have emitted a
1545                 dynamic symbol entry for the got section, so idx will be
1546                 zero, which means we can and should compute the address
1547                 of the private descriptor ourselves.  */
1548              if (info->executable && !info->pie
1549                  && (entry->symndx != -1
1550                      || FRVFDPIC_FUNCDESC_LOCAL (info, entry->d.h)))
1551                {
1552                  ad += frvfdpic_got_section (info)->output_section->vma;
1553                  _frvfdpic_add_rofixup (output_bfd,
1554                                         frvfdpic_gotfixup_section (info),
1555                                         frvfdpic_got_section (info)
1556                                         ->output_section->vma
1557                                         + frvfdpic_got_section (info)
1558                                         ->output_offset
1559                                         + frvfdpic_got_initial_offset (info)
1560                                         + entry->fdgot_entry, entry);
1561                }
1562              else
1563                _frvfdpic_add_dyn_reloc (output_bfd,
1564                                         frvfdpic_gotrel_section (info),
1565                                         _bfd_elf_section_offset
1566                                         (output_bfd, info,
1567                                          frvfdpic_got_section (info),
1568                                          frvfdpic_got_initial_offset (info)
1569                                          + entry->fdgot_entry)
1570                                         + frvfdpic_got_section (info)
1571                                         ->output_section->vma
1572                                         + frvfdpic_got_section (info)
1573                                         ->output_offset,
1574                                         reloc, idx, ad, entry);
1575            }
1576    
1577          bfd_put_32 (output_bfd, ad,
1578                      frvfdpic_got_section (info)->contents
1579                      + frvfdpic_got_initial_offset (info)
1580                      + entry->fdgot_entry);
1581        }
1582    
1583      /* Generate relocation to fill in a private function descriptor in
1584         the GOT.  */
1585      if (entry->fd_entry)
1586        {
1587          int idx = dynindx;
1588          bfd_vma ad = addend;
1589          bfd_vma ofst;
1590          long lowword, highword;
1591    
1592          /* If the symbol is dynamic but binds locally, use
1593             section+offset.  */
1594          if (sec && (entry->symndx != -1
1595                      || FRVFDPIC_SYM_LOCAL (info, entry->d.h)))
1596            {
1597              if (entry->symndx == -1)
1598                ad += entry->d.h->root.u.def.value;
1599              else
1600                ad += sym->st_value;
1601              ad += sec->output_offset;
1602              if (sec->output_section && elf_section_data (sec->output_section))
1603                idx = elf_section_data (sec->output_section)->dynindx;
1604              else
1605                idx = 0;
1606            }
1607    
1608          /* If we're linking an executable at a fixed address, we can
1609             omit the dynamic relocation as long as the symbol is local to
1610             this module.  */
1611          if (info->executable && !info->pie
1612              && (entry->symndx != -1 || FRVFDPIC_SYM_LOCAL (info, entry->d.h)))
1613            {
1614              if (sec)
1615                ad += sec->output_section->vma;
1616              ofst = 0;
1617              if (entry->symndx != -1
1618                  || entry->d.h->root.type != bfd_link_hash_undefweak)
1619                {
1620                  _frvfdpic_add_rofixup (output_bfd,
1621                                         frvfdpic_gotfixup_section (info),
1622                                         frvfdpic_got_section (info)
1623                                         ->output_section->vma
1624                                         + frvfdpic_got_section (info)
1625                                         ->output_offset
1626                                         + frvfdpic_got_initial_offset (info)
1627                                         + entry->fd_entry, entry);
1628                  _frvfdpic_add_rofixup (output_bfd,
1629                                         frvfdpic_gotfixup_section (info),
1630                                         frvfdpic_got_section (info)
1631                                         ->output_section->vma
1632                                         + frvfdpic_got_section (info)
1633                                         ->output_offset
1634                                         + frvfdpic_got_initial_offset (info)
1635                                         + entry->fd_entry + 4, entry);
1636                }
1637            }
1638          else
1639            {
1640              ofst =
1641                _frvfdpic_add_dyn_reloc (output_bfd,
1642                                         entry->lazyplt
1643                                         ? frvfdpic_pltrel_section (info)
1644                                         : frvfdpic_gotrel_section (info),
1645                                         _bfd_elf_section_offset
1646                                         (output_bfd, info,
1647                                          frvfdpic_got_section (info),
1648                                          frvfdpic_got_initial_offset (info)
1649                                          + entry->fd_entry)
1650                                         + frvfdpic_got_section (info)
1651                                         ->output_section->vma
1652                                         + frvfdpic_got_section (info)
1653                                         ->output_offset,
1654                                         R_FRV_FUNCDESC_VALUE, idx, ad, entry);
1655            }
1656    
1657          /* If we've omitted the dynamic relocation, just emit the fixed
1658             addresses of the symbol and of the local GOT base offset.  */
1659          if (info->executable && !info->pie && sec && sec->output_section)
1660            {
1661              lowword = ad;
1662              highword = frvfdpic_got_section (info)->output_section->vma
1663                + frvfdpic_got_section (info)->output_offset
1664                + frvfdpic_got_initial_offset (info);
1665            }
1666          else if (entry->lazyplt)
1667            {
1668              if (ad)
1669                {
1670                  (*info->callbacks->reloc_dangerous)
1671                    (info, _("relocation requires zero addend"),
1672                     elf_hash_table (info)->dynobj,
1673                     frvfdpic_got_section (info),
1674                     entry->fd_entry);
1675                  return FALSE;
1676                }
1677    
1678              fd_lazy_rel_offset = ofst;
1679    
1680              /* A function descriptor used for lazy or local resolving is
1681                 initialized such that its high word contains the output
1682                 section index in which the PLT entries are located, and
1683                 the low word contains the address of the lazy PLT entry
1684                 entry point, that must be within the memory region
1685                 assigned to that section.  */
1686              lowword = entry->lzplt_entry + 4
1687                + frvfdpic_plt_section (info)->output_offset
1688                + frvfdpic_plt_section (info)->output_section->vma;
1689              highword = _frvfdpic_osec_to_segment
1690                (output_bfd, frvfdpic_plt_section (info)->output_section);
1691            }
1692          else
1693            {
1694              /* A function descriptor for a local function gets the index
1695                 of the section.  For a non-local function, it's
1696                 disregarded.  */
1697              lowword = ad;
1698              if (entry->symndx == -1 && entry->d.h->dynindx != -1
1699                  && entry->d.h->dynindx == idx)
1700                highword = 0;
1701              else
1702                highword = _frvfdpic_osec_to_segment
1703                  (output_bfd, sec->output_section);
1704            }
1705    
1706          bfd_put_32 (output_bfd, lowword,
1707                      frvfdpic_got_section (info)->contents
1708                      + frvfdpic_got_initial_offset (info)
1709                      + entry->fd_entry);
1710          bfd_put_32 (output_bfd, highword,
1711                      frvfdpic_got_section (info)->contents
1712                      + frvfdpic_got_initial_offset (info)
1713                      + entry->fd_entry + 4);
1714        }
1715    
1716      /* Generate code for the PLT entry.  */
1717      if (entry->plt_entry != (bfd_vma) -1)
1718        {
1719          bfd_byte *plt_code = frvfdpic_plt_section (info)->contents
1720            + entry->plt_entry;
1721    
1722          BFD_ASSERT (entry->fd_entry);
1723    
1724          /* Figure out what kind of PLT entry we need, depending on the
1725             location of the function descriptor within the GOT.  */
1726          if (entry->fd_entry >= -(1 << (12 - 1))
1727              && entry->fd_entry < (1 << (12 - 1)))
1728            {
1729              /* lddi @(gr15, fd_entry), gr14 */
1730              bfd_put_32 (output_bfd,
1731                          0x9cccf000 | (entry->fd_entry & ((1 << 12) - 1)),
1732                          plt_code);
1733              plt_code += 4;
1734            }
1735          else
1736            {
1737              if (entry->fd_entry >= -(1 << (16 - 1))
1738                  && entry->fd_entry < (1 << (16 - 1)))
1739                {
1740                  /* setlos lo(fd_entry), gr14 */
1741                  bfd_put_32 (output_bfd,
1742                              0x9cfc0000
1743                              | (entry->fd_entry & (((bfd_vma)1 << 16) - 1)),
1744                              plt_code);
1745                  plt_code += 4;
1746                }
1747              else
1748                {
1749                  /* sethi.p hi(fd_entry), gr14
1750                     setlo lo(fd_entry), gr14 */
1751                  bfd_put_32 (output_bfd,
1752                              0x1cf80000
1753                              | ((entry->fd_entry >> 16)
1754                                 & (((bfd_vma)1 << 16) - 1)),
1755                              plt_code);
1756                  plt_code += 4;
1757                  bfd_put_32 (output_bfd,
1758                              0x9cf40000
1759                              | (entry->fd_entry & (((bfd_vma)1 << 16) - 1)),
1760                              plt_code);
1761                  plt_code += 4;
1762                }
1763              /* ldd @(gr14,gr15),gr14 */
1764              bfd_put_32 (output_bfd, 0x9c08e14f, plt_code);
1765              plt_code += 4;
1766            }
1767          /* jmpl @(gr14,gr0) */
1768          bfd_put_32 (output_bfd, 0x8030e000, plt_code);
1769        }
1770    
1771      /* Generate code for the lazy PLT entry.  */
1772      if (entry->lzplt_entry != (bfd_vma) -1)
1773        {
1774          bfd_byte *lzplt_code = frvfdpic_plt_section (info)->contents
1775            + entry->lzplt_entry;
1776          bfd_vma resolverStub_addr;
1777    
1778          bfd_put_32 (output_bfd, fd_lazy_rel_offset, lzplt_code);
1779          lzplt_code += 4;
1780    
1781          resolverStub_addr = entry->lzplt_entry / FRVFDPIC_LZPLT_BLOCK_SIZE
1782            * FRVFDPIC_LZPLT_BLOCK_SIZE + FRVFDPIC_LZPLT_RESOLV_LOC;
1783          if (resolverStub_addr >= frvfdpic_plt_initial_offset (info))
1784            resolverStub_addr = frvfdpic_plt_initial_offset (info) - 12;
1785    
1786          if (entry->lzplt_entry == resolverStub_addr)
1787            {
1788              /* This is a lazy PLT entry that includes a resolver call.  */
1789              /* ldd @(gr15,gr0), gr4
1790                 jmpl @(gr4,gr0)  */
1791              bfd_put_32 (output_bfd, 0x8808f140, lzplt_code);
1792              bfd_put_32 (output_bfd, 0x80304000, lzplt_code + 4);
1793            }
1794          else
1795            {
1796              /* bra  resolverStub */
1797              bfd_put_32 (output_bfd,
1798                          0xc01a0000
1799                          | (((resolverStub_addr - entry->lzplt_entry)
1800                              / 4) & (((bfd_vma)1 << 16) - 1)),
1801                          lzplt_code);
1802            }
1803        }
1804    
1805      /* Generate relocation for GOT entry holding the TLS offset.  */
1806      if (entry->tlsoff_entry)
1807        {
1808          int idx = dynindx;
1809          bfd_vma ad = addend;
1810    
1811          if (entry->symndx != -1
1812              || FRVFDPIC_SYM_LOCAL (info, entry->d.h))
1813            {
1814              /* If the symbol is dynamic but binds locally, use
1815                 section+offset.  */
1816              if (sec)
1817                {
1818                  if (entry->symndx == -1)
1819                    ad += entry->d.h->root.u.def.value;
1820                  else
1821                    ad += sym->st_value;
1822                  ad += sec->output_offset;
1823                  if (sec->output_section
1824                      && elf_section_data (sec->output_section))
1825                    idx = elf_section_data (sec->output_section)->dynindx;
1826                  else
1827                    idx = 0;
1828                }
1829            }
1830    
1831          /* *ABS*+addend is special for TLS relocations, use only the
1832             addend.  */
1833          if (info->executable
1834              && idx == 0
1835              && (bfd_is_abs_section (sec)
1836                  || bfd_is_und_section (sec)))
1837            ;
1838          /* If we're linking an executable, we can entirely omit the
1839             dynamic relocation if the symbol is local to this module.  */
1840          else if (info->executable
1841                   && (entry->symndx != -1
1842                       || FRVFDPIC_SYM_LOCAL (info, entry->d.h)))
1843            {
1844              if (sec)
1845                ad += sec->output_section->vma - tls_biased_base (info);
1846            }
1847          else
1848            {
1849              if (idx == 0
1850                  && (bfd_is_abs_section (sec)
1851                      || bfd_is_und_section (sec)))
1852                {
1853                  if (! elf_hash_table (info)->tls_sec)
1854                    {
1855                      (*info->callbacks->undefined_symbol)
1856                        (info, "TLS section", elf_hash_table (info)->dynobj,
1857                         frvfdpic_got_section (info), entry->tlsoff_entry, TRUE);
1858                      return FALSE;
1859                    }
1860                  idx = elf_section_data (elf_hash_table (info)->tls_sec)->dynindx;
1861                  ad += FRVFDPIC_TLS_BIAS;
1862                }
1863              _frvfdpic_add_dyn_reloc (output_bfd, frvfdpic_gotrel_section (info),
1864                                       _bfd_elf_section_offset
1865                                       (output_bfd, info,
1866                                        frvfdpic_got_section (info),
1867                                        frvfdpic_got_initial_offset (info)
1868                                        + entry->tlsoff_entry)
1869                                       + frvfdpic_got_section (info)
1870                                       ->output_section->vma
1871                                       + frvfdpic_got_section (info)
1872                                       ->output_offset,
1873                                       R_FRV_TLSOFF, idx, ad, entry);
1874            }
1875            
1876          bfd_put_32 (output_bfd, ad,
1877                      frvfdpic_got_section (info)->contents
1878                      + frvfdpic_got_initial_offset (info)
1879                      + entry->tlsoff_entry);
1880        }
1881    
1882      if (entry->tlsdesc_entry)
1883        {
1884          int idx = dynindx;
1885          bfd_vma ad = addend;
1886    
1887          /* If the symbol is dynamic but binds locally, use
1888             section+offset.  */
1889          if (sec && (entry->symndx != -1
1890                      || FRVFDPIC_SYM_LOCAL (info, entry->d.h)))
1891            {
1892              if (entry->symndx == -1)
1893                ad += entry->d.h->root.u.def.value;
1894              else
1895                ad += sym->st_value;
1896              ad += sec->output_offset;
1897              if (sec->output_section && elf_section_data (sec->output_section))
1898                idx = elf_section_data (sec->output_section)->dynindx;
1899              else
1900                idx = 0;
1901            }
1902    
1903          /* If we didn't set up a TLS offset entry, but we're linking an
1904             executable and the symbol binds locally, we can use the
1905             module offset in the TLS descriptor in relaxations.  */
1906          if (info->executable && ! entry->tlsoff_entry)
1907            entry->tlsoff_entry = entry->tlsdesc_entry + 4;
1908    
1909          if (info->executable && !info->pie
1910              && ((idx == 0
1911                   && (bfd_is_abs_section (sec)
1912                       || bfd_is_und_section (sec)))
1913                  || entry->symndx != -1
1914                  || FRVFDPIC_SYM_LOCAL (info, entry->d.h)))
1915            {
1916              /* *ABS*+addend is special for TLS relocations, use only the
1917                 addend for the TLS offset, and take the module id as
1918                 0.  */
1919              if (idx == 0
1920                  && (bfd_is_abs_section (sec)
1921                      || bfd_is_und_section (sec)))
1922                ;
1923              /* For other TLS symbols that bind locally, add the section
1924                 TLS offset to the addend.  */
1925              else if (sec)
1926                ad += sec->output_section->vma - tls_biased_base (info);
1927    
1928              bfd_put_32 (output_bfd,
1929                          frvfdpic_plt_section (info)->output_section->vma
1930                          + frvfdpic_plt_section (info)->output_offset
1931                          + frvfdpic_plt_tls_ret_offset (info),
1932                          frvfdpic_got_section (info)->contents
1933                          + frvfdpic_got_initial_offset (info)
1934                          + entry->tlsdesc_entry);
1935    
1936              _frvfdpic_add_rofixup (output_bfd,
1937                                     frvfdpic_gotfixup_section (info),
1938                                     frvfdpic_got_section (info)
1939                                     ->output_section->vma
1940                                     + frvfdpic_got_section (info)
1941                                     ->output_offset
1942                                     + frvfdpic_got_initial_offset (info)
1943                                     + entry->tlsdesc_entry, entry);
1944    
1945              BFD_ASSERT (frvfdpic_dynamic_got_plt_info (info)->tls_ret_refs);
1946    
1947              /* We've used one of the reserved fixups, so discount it so
1948                 that we can check at the end that we've used them
1949                 all.  */
1950              frvfdpic_dynamic_got_plt_info (info)->tls_ret_refs--;
1951    
1952              /* While at that, make sure the ret instruction makes to the
1953                 right location in the PLT.  We could do it only when we
1954                 got to 0, but since the check at the end will only print
1955                 a warning, make sure we have the ret in place in case the
1956                 warning is missed.  */
1957              bfd_put_32 (output_bfd, 0xc03a4000,
1958                          frvfdpic_plt_section (info)->contents
1959                          + frvfdpic_plt_tls_ret_offset (info));
1960            }
1961          else
1962            {
1963              if (idx == 0
1964                  && (bfd_is_abs_section (sec)
1965                      || bfd_is_und_section (sec)))
1966                {
1967                  if (! elf_hash_table (info)->tls_sec)
1968                    {
1969                      (*info->callbacks->undefined_symbol)
1970                        (info, "TLS section", elf_hash_table (info)->dynobj,
1971                         frvfdpic_got_section (info), entry->tlsdesc_entry, TRUE);
1972                      return FALSE;
1973                    }
1974                  idx = elf_section_data (elf_hash_table (info)->tls_sec)->dynindx;
1975                  ad += FRVFDPIC_TLS_BIAS;
1976                }
1977    
1978              _frvfdpic_add_dyn_reloc (output_bfd, frvfdpic_gotrel_section (info),
1979                                       _bfd_elf_section_offset
1980                                       (output_bfd, info,
1981                                        frvfdpic_got_section (info),
1982                                        frvfdpic_got_initial_offset (info)
1983                                        + entry->tlsdesc_entry)
1984                                       + frvfdpic_got_section (info)
1985                                       ->output_section->vma
1986                                       + frvfdpic_got_section (info)
1987                                       ->output_offset,
1988                                       R_FRV_TLSDESC_VALUE, idx, ad, entry);
1989    
1990              bfd_put_32 (output_bfd, 0,
1991                          frvfdpic_got_section (info)->contents
1992                          + frvfdpic_got_initial_offset (info)
1993                          + entry->tlsdesc_entry);
1994            }
1995    
1996          bfd_put_32 (output_bfd, ad,
1997                      frvfdpic_got_section (info)->contents
1998                      + frvfdpic_got_initial_offset (info)
1999                      + entry->tlsdesc_entry + 4);
2000        }
2001    
2002      /* Generate code for the get-TLS-offset PLT entry.  */
2003      if (entry->tlsplt_entry != (bfd_vma) -1)
2004        {
2005          bfd_byte *plt_code = frvfdpic_plt_section (info)->contents
2006            + entry->tlsplt_entry;
2007          
2008          if (info->executable
2009              && (entry->symndx != -1
2010                  || FRVFDPIC_SYM_LOCAL (info, entry->d.h)))
2011            {
2012              int idx = dynindx;
2013              bfd_vma ad = addend;
2014    
2015              /* sec may be NULL when referencing an undefweak symbol
2016                 while linking a static executable.  */
2017              if (!sec)
2018                {
2019                  BFD_ASSERT (entry->symndx == -1
2020                              && entry->d.h->root.type == bfd_link_hash_undefweak);
2021                }
2022              else
2023                {
2024                  if (entry->symndx == -1)
2025                    ad += entry->d.h->root.u.def.value;
2026                  else
2027                    ad += sym->st_value;
2028                  ad += sec->output_offset;
2029                  if (sec->output_section
2030                      && elf_section_data (sec->output_section))
2031                    idx = elf_section_data (sec->output_section)->dynindx;
2032                  else
2033                    idx = 0;
2034                }
2035              
2036              /* *ABS*+addend is special for TLS relocations, use only the
2037                 addend for the TLS offset, and take the module id as
2038                 0.  */
2039              if (idx == 0
2040                  && (bfd_is_abs_section (sec)
2041                      || bfd_is_und_section (sec)))
2042                ;
2043              /* For other TLS symbols that bind locally, add the section
2044                 TLS offset to the addend.  */
2045              else if (sec)
2046                ad += sec->output_section->vma - tls_biased_base (info);
2047              
2048              if ((bfd_signed_vma)ad >= -(1 << (16 - 1))
2049                  && (bfd_signed_vma)ad < (1 << (16 - 1)))
2050                {
2051                  /* setlos lo(ad), gr9 */
2052                  bfd_put_32 (output_bfd,
2053                              0x92fc0000
2054                              | (ad
2055                                 & (((bfd_vma)1 << 16) - 1)),
2056                              plt_code);
2057                  plt_code += 4;
2058                }
2059              else
2060                {
2061                  /* sethi.p hi(ad), gr9
2062                     setlo lo(ad), gr9 */
2063                  bfd_put_32 (output_bfd,
2064                              0x12f80000
2065                              | ((ad >> 16)
2066                                 & (((bfd_vma)1 << 16) - 1)),
2067                              plt_code);
2068                  plt_code += 4;
2069                  bfd_put_32 (output_bfd,
2070                              0x92f40000
2071                              | (ad
2072                                 & (((bfd_vma)1 << 16) - 1)),
2073                              plt_code);
2074                  plt_code += 4;
2075                }
2076              /* ret */
2077              bfd_put_32 (output_bfd, 0xc03a4000, plt_code);
2078            }
2079          else if (entry->tlsoff_entry)
2080            {
2081              /* Figure out what kind of PLT entry we need, depending on the
2082                 location of the TLS descriptor within the GOT.  */
2083              if (entry->tlsoff_entry >= -(1 << (12 - 1))
2084                  && entry->tlsoff_entry < (1 << (12 - 1)))
2085                {
2086                  /* ldi @(gr15, tlsoff_entry), gr9 */
2087                  bfd_put_32 (output_bfd,
2088                              0x92c8f000 | (entry->tlsoff_entry
2089                                            & ((1 << 12) - 1)),
2090                              plt_code);
2091                  plt_code += 4;
2092                }
2093              else
2094                {
2095                  if (entry->tlsoff_entry >= -(1 << (16 - 1))
2096                      && entry->tlsoff_entry < (1 << (16 - 1)))
2097                    {
2098                      /* setlos lo(tlsoff_entry), gr8 */
2099                      bfd_put_32 (output_bfd,
2100                                  0x90fc0000
2101                                  | (entry->tlsoff_entry
2102                                     & (((bfd_vma)1 << 16) - 1)),
2103                                  plt_code);
2104                      plt_code += 4;
2105                    }
2106                  else
2107                    {
2108                      /* sethi.p hi(tlsoff_entry), gr8
2109                         setlo lo(tlsoff_entry), gr8 */
2110                      bfd_put_32 (output_bfd,
2111                                  0x10f80000
2112                                  | ((entry->tlsoff_entry >> 16)
2113                                     & (((bfd_vma)1 << 16) - 1)),
2114                                  plt_code);
2115                      plt_code += 4;
2116                      bfd_put_32 (output_bfd,
2117                                  0x90f40000
2118                                  | (entry->tlsoff_entry
2119                                     & (((bfd_vma)1 << 16) - 1)),
2120                                  plt_code);
2121                      plt_code += 4;
2122                    }
2123                  /* ld @(gr15,gr8),gr9 */
2124                  bfd_put_32 (output_bfd, 0x9008f108, plt_code);
2125                  plt_code += 4;
2126                }
2127              /* ret */
2128              bfd_put_32 (output_bfd, 0xc03a4000, plt_code);
2129            }
2130          else
2131            {
2132              BFD_ASSERT (entry->tlsdesc_entry);
2133    
2134              /* Figure out what kind of PLT entry we need, depending on the
2135                 location of the TLS descriptor within the GOT.  */
2136              if (entry->tlsdesc_entry >= -(1 << (12 - 1))
2137                  && entry->tlsdesc_entry < (1 << (12 - 1)))
2138                {
2139                  /* lddi @(gr15, tlsdesc_entry), gr8 */
2140                  bfd_put_32 (output_bfd,
2141                              0x90ccf000 | (entry->tlsdesc_entry
2142                                            & ((1 << 12) - 1)),
2143                              plt_code);
2144                  plt_code += 4;
2145                }
2146              else
2147                {
2148                  if (entry->tlsdesc_entry >= -(1 << (16 - 1))
2149                      && entry->tlsdesc_entry < (1 << (16 - 1)))
2150                    {
2151                      /* setlos lo(tlsdesc_entry), gr8 */
2152                      bfd_put_32 (output_bfd,
2153                                  0x90fc0000
2154                                  | (entry->tlsdesc_entry
2155                                     & (((bfd_vma)1 << 16) - 1)),
2156                                  plt_code);
2157                      plt_code += 4;
2158                    }
2159                  else
2160                    {
2161                      /* sethi.p hi(tlsdesc_entry), gr8
2162                         setlo lo(tlsdesc_entry), gr8 */
2163                      bfd_put_32 (output_bfd,
2164                                  0x10f80000
2165                                  | ((entry->tlsdesc_entry >> 16)
2166                                     & (((bfd_vma)1 << 16) - 1)),
2167                                  plt_code);
2168                      plt_code += 4;
2169                      bfd_put_32 (output_bfd,
2170                                  0x90f40000
2171                                  | (entry->tlsdesc_entry
2172                                     & (((bfd_vma)1 << 16) - 1)),
2173                                  plt_code);
2174                      plt_code += 4;
2175                    }
2176                  /* ldd @(gr15,gr8),gr8 */
2177                  bfd_put_32 (output_bfd, 0x9008f148, plt_code);
2178                  plt_code += 4;
2179                }
2180              /* jmpl @(gr8,gr0) */
2181              bfd_put_32 (output_bfd, 0x80308000, plt_code);
2182            }
2183        }
2184    
2185      return TRUE;
2186    }
2187    
2188  /* Handle an FRV small data reloc.  */  /* Handle an FRV small data reloc.  */
2189    
2190  static bfd_reloc_status_type  static bfd_reloc_status_type
2191  elf32_frv_relocate_gprel12 (info, input_bfd, input_section, relocation, contents, value)  elf32_frv_relocate_gprel12 (info, input_bfd, input_section, relocation,
2192                                contents, value)
2193       struct bfd_link_info *info;       struct bfd_link_info *info;
2194       bfd *input_bfd;       bfd *input_bfd;
2195       asection *input_section;       asection *input_section;
# Line 295  elf32_frv_relocate_gprel12 (info, input_ Line 2201  elf32_frv_relocate_gprel12 (info, input_
2201    bfd_vma gp;    bfd_vma gp;
2202    struct bfd_link_hash_entry *h;    struct bfd_link_hash_entry *h;
2203    
2204    h = bfd_link_hash_lookup (info->hash, "_gp", false, false, true);    h = bfd_link_hash_lookup (info->hash, "_gp", FALSE, FALSE, TRUE);
2205    
2206    gp = (h->u.def.value    gp = (h->u.def.value
2207          + h->u.def.section->output_section->vma          + h->u.def.section->output_section->vma
# Line 321  elf32_frv_relocate_gprel12 (info, input_ Line 2227  elf32_frv_relocate_gprel12 (info, input_
2227  /* Handle an FRV small data reloc. for the u12 field.  */  /* Handle an FRV small data reloc. for the u12 field.  */
2228    
2229  static bfd_reloc_status_type  static bfd_reloc_status_type
2230  elf32_frv_relocate_gprelu12 (info, input_bfd, input_section, relocation, contents, value)  elf32_frv_relocate_gprelu12 (info, input_bfd, input_section, relocation,
2231                                 contents, value)
2232       struct bfd_link_info *info;       struct bfd_link_info *info;
2233       bfd *input_bfd;       bfd *input_bfd;
2234       asection *input_section;       asection *input_section;
# Line 334  elf32_frv_relocate_gprelu12 (info, input Line 2241  elf32_frv_relocate_gprelu12 (info, input
2241    struct bfd_link_hash_entry *h;    struct bfd_link_hash_entry *h;
2242    bfd_vma mask;    bfd_vma mask;
2243    
2244    h = bfd_link_hash_lookup (info->hash, "_gp", false, false, true);    h = bfd_link_hash_lookup (info->hash, "_gp", FALSE, FALSE, TRUE);
2245    
2246    gp = (h->u.def.value    gp = (h->u.def.value
2247          + h->u.def.section->output_section->vma          + h->u.def.section->output_section->vma
2248          + h->u.def.section->output_offset);          + h->u.def.section->output_offset);
2249    
2250    value -= input_section->output_section->vma;    value -= input_section->output_section->vma;
2251    value -= (gp - input_section->output_section->vma);    value -= (gp - input_section->output_section->vma);
2252    
# Line 423  elf32_frv_relocate_label24 (input_bfd, i Line 2330  elf32_frv_relocate_label24 (input_bfd, i
2330    
2331    /* The format for the call instruction is:    /* The format for the call instruction is:
2332    
2333      0 000000 0001111 000000000000000000      0 000000 0001111 000000000000000000
2334        label6 opcode  label18        label6 opcode  label18
2335    
2336      The branch calculation is: pc + (4*label24)      The branch calculation is: pc + (4*label24)
# Line 453  elf32_frv_relocate_label24 (input_bfd, i Line 2360  elf32_frv_relocate_label24 (input_bfd, i
2360  }  }
2361    
2362  static bfd_reloc_status_type  static bfd_reloc_status_type
2363  elf32_frv_relocate_gprelhi (info, input_bfd, input_section, relocation, contents, value)  elf32_frv_relocate_gprelhi (info, input_bfd, input_section, relocation,
2364                                contents, value)
2365       struct bfd_link_info *info;       struct bfd_link_info *info;
2366       bfd *input_bfd;       bfd *input_bfd;
2367       asection *input_section;       asection *input_section;
# Line 465  elf32_frv_relocate_gprelhi (info, input_ Line 2373  elf32_frv_relocate_gprelhi (info, input_
2373    bfd_vma gp;    bfd_vma gp;
2374    struct bfd_link_hash_entry *h;    struct bfd_link_hash_entry *h;
2375    
2376    h = bfd_link_hash_lookup (info->hash, "_gp", false, false, true);    h = bfd_link_hash_lookup (info->hash, "_gp", FALSE, FALSE, TRUE);
2377    
2378    gp = (h->u.def.value    gp = (h->u.def.value
2379          + h->u.def.section->output_section->vma          + h->u.def.section->output_section->vma
# Line 487  elf32_frv_relocate_gprelhi (info, input_ Line 2395  elf32_frv_relocate_gprelhi (info, input_
2395  }  }
2396    
2397  static bfd_reloc_status_type  static bfd_reloc_status_type
2398  elf32_frv_relocate_gprello (info, input_bfd, input_section, relocation, contents, value)  elf32_frv_relocate_gprello (info, input_bfd, input_section, relocation,
2399                                contents, value)
2400       struct bfd_link_info *info;       struct bfd_link_info *info;
2401       bfd *input_bfd;       bfd *input_bfd;
2402       asection *input_section;       asection *input_section;
# Line 499  elf32_frv_relocate_gprello (info, input_ Line 2408  elf32_frv_relocate_gprello (info, input_
2408    bfd_vma gp;    bfd_vma gp;
2409    struct bfd_link_hash_entry *h;    struct bfd_link_hash_entry *h;
2410    
2411    h = bfd_link_hash_lookup (info->hash, "_gp", false, false, true);    h = bfd_link_hash_lookup (info->hash, "_gp", FALSE, FALSE, TRUE);
2412    
2413    gp = (h->u.def.value    gp = (h->u.def.value
2414          + h->u.def.section->output_section->vma          + h->u.def.section->output_section->vma
# Line 523  elf32_frv_relocate_gprello (info, input_ Line 2432  elf32_frv_relocate_gprello (info, input_
2432    
2433  static reloc_howto_type *  static reloc_howto_type *
2434  frv_reloc_type_lookup (abfd, code)  frv_reloc_type_lookup (abfd, code)
2435       bfd * abfd ATTRIBUTE_UNUSED;       bfd *abfd ATTRIBUTE_UNUSED;
2436       bfd_reloc_code_real_type code;       bfd_reloc_code_real_type code;
2437  {  {
2438    switch (code)    switch (code)
# Line 533  frv_reloc_type_lookup (abfd, code) Line 2442  frv_reloc_type_lookup (abfd, code)
2442    
2443      case BFD_RELOC_NONE:      case BFD_RELOC_NONE:
2444        return &elf32_frv_howto_table[ (int) R_FRV_NONE];        return &elf32_frv_howto_table[ (int) R_FRV_NONE];
2445      
2446      case BFD_RELOC_32:      case BFD_RELOC_32:
2447          if (elf_elfheader (abfd)->e_type == ET_EXEC
2448              || elf_elfheader (abfd)->e_type == ET_DYN)
2449            return &elf32_frv_rel_32_howto;
2450          /* Fall through.  */
2451      case BFD_RELOC_CTOR:      case BFD_RELOC_CTOR:
2452        return &elf32_frv_howto_table[ (int) R_FRV_32];        return &elf32_frv_howto_table[ (int) R_FRV_32];
2453    
# Line 565  frv_reloc_type_lookup (abfd, code) Line 2478  frv_reloc_type_lookup (abfd, code)
2478      case BFD_RELOC_FRV_GPRELLO:      case BFD_RELOC_FRV_GPRELLO:
2479        return &elf32_frv_howto_table[ (int) R_FRV_GPRELLO];        return &elf32_frv_howto_table[ (int) R_FRV_GPRELLO];
2480    
2481        case BFD_RELOC_FRV_GOT12:
2482          return &elf32_frv_howto_table[ (int) R_FRV_GOT12];
2483    
2484        case BFD_RELOC_FRV_GOTHI:
2485          return &elf32_frv_howto_table[ (int) R_FRV_GOTHI];
2486    
2487        case BFD_RELOC_FRV_GOTLO:
2488          return &elf32_frv_howto_table[ (int) R_FRV_GOTLO];
2489    
2490        case BFD_RELOC_FRV_FUNCDESC:
2491          if (elf_elfheader (abfd)->e_type == ET_EXEC
2492              || elf_elfheader (abfd)->e_type == ET_DYN)
2493            return &elf32_frv_rel_funcdesc_howto;
2494          return &elf32_frv_howto_table[ (int) R_FRV_FUNCDESC];
2495    
2496        case BFD_RELOC_FRV_FUNCDESC_GOT12:
2497          return &elf32_frv_howto_table[ (int) R_FRV_FUNCDESC_GOT12];
2498    
2499        case BFD_RELOC_FRV_FUNCDESC_GOTHI:
2500          return &elf32_frv_howto_table[ (int) R_FRV_FUNCDESC_GOTHI];
2501    
2502        case BFD_RELOC_FRV_FUNCDESC_GOTLO:
2503          return &elf32_frv_howto_table[ (int) R_FRV_FUNCDESC_GOTLO];
2504    
2505        case BFD_RELOC_FRV_FUNCDESC_VALUE:
2506          if (elf_elfheader (abfd)->e_type == ET_EXEC
2507              || elf_elfheader (abfd)->e_type == ET_DYN)
2508            return &elf32_frv_rel_funcdesc_value_howto;
2509          return &elf32_frv_howto_table[ (int) R_FRV_FUNCDESC_VALUE];
2510    
2511        case BFD_RELOC_FRV_FUNCDESC_GOTOFF12:
2512          return &elf32_frv_howto_table[ (int) R_FRV_FUNCDESC_GOTOFF12];
2513    
2514        case BFD_RELOC_FRV_FUNCDESC_GOTOFFHI:
2515          return &elf32_frv_howto_table[ (int) R_FRV_FUNCDESC_GOTOFFHI];
2516    
2517        case BFD_RELOC_FRV_FUNCDESC_GOTOFFLO:
2518          return &elf32_frv_howto_table[ (int) R_FRV_FUNCDESC_GOTOFFLO];
2519    
2520        case BFD_RELOC_FRV_GOTOFF12:
2521          return &elf32_frv_howto_table[ (int) R_FRV_GOTOFF12];
2522    
2523        case BFD_RELOC_FRV_GOTOFFHI:
2524          return &elf32_frv_howto_table[ (int) R_FRV_GOTOFFHI];
2525    
2526        case BFD_RELOC_FRV_GOTOFFLO:
2527          return &elf32_frv_howto_table[ (int) R_FRV_GOTOFFLO];
2528    
2529        case BFD_RELOC_FRV_GETTLSOFF:
2530          return &elf32_frv_howto_table[ (int) R_FRV_GETTLSOFF];
2531    
2532        case BFD_RELOC_FRV_TLSDESC_VALUE:
2533          if (elf_elfheader (abfd)->e_type == ET_EXEC
2534              || elf_elfheader (abfd)->e_type == ET_DYN)
2535            return &elf32_frv_rel_tlsdesc_value_howto;
2536          return &elf32_frv_howto_table[ (int) R_FRV_TLSDESC_VALUE];
2537    
2538        case BFD_RELOC_FRV_GOTTLSDESC12:
2539          return &elf32_frv_howto_table[ (int) R_FRV_GOTTLSDESC12];
2540    
2541        case BFD_RELOC_FRV_GOTTLSDESCHI:
2542          return &elf32_frv_howto_table[ (int) R_FRV_GOTTLSDESCHI];
2543    
2544        case BFD_RELOC_FRV_GOTTLSDESCLO:
2545          return &elf32_frv_howto_table[ (int) R_FRV_GOTTLSDESCLO];
2546    
2547        case BFD_RELOC_FRV_TLSMOFF12:
2548          return &elf32_frv_howto_table[ (int) R_FRV_TLSMOFF12];
2549    
2550        case BFD_RELOC_FRV_TLSMOFFHI:
2551          return &elf32_frv_howto_table[ (int) R_FRV_TLSMOFFHI];
2552    
2553        case BFD_RELOC_FRV_TLSMOFFLO:
2554          return &elf32_frv_howto_table[ (int) R_FRV_TLSMOFFLO];
2555    
2556        case BFD_RELOC_FRV_GOTTLSOFF12:
2557          return &elf32_frv_howto_table[ (int) R_FRV_GOTTLSOFF12];
2558    
2559        case BFD_RELOC_FRV_GOTTLSOFFHI:
2560          return &elf32_frv_howto_table[ (int) R_FRV_GOTTLSOFFHI];
2561    
2562        case BFD_RELOC_FRV_GOTTLSOFFLO:
2563          return &elf32_frv_howto_table[ (int) R_FRV_GOTTLSOFFLO];
2564    
2565        case BFD_RELOC_FRV_TLSOFF:
2566          if (elf_elfheader (abfd)->e_type == ET_EXEC
2567              || elf_elfheader (abfd)->e_type == ET_DYN)
2568            return &elf32_frv_rel_tlsoff_howto;
2569          return &elf32_frv_howto_table[ (int) R_FRV_TLSOFF];
2570    
2571        case BFD_RELOC_FRV_TLSDESC_RELAX:
2572          return &elf32_frv_howto_table[ (int) R_FRV_TLSDESC_RELAX];
2573    
2574        case BFD_RELOC_FRV_GETTLSOFF_RELAX:
2575          return &elf32_frv_howto_table[ (int) R_FRV_GETTLSOFF_RELAX];
2576    
2577        case BFD_RELOC_FRV_TLSOFF_RELAX:
2578          return &elf32_frv_howto_table[ (int) R_FRV_TLSOFF_RELAX];
2579    
2580        case BFD_RELOC_FRV_TLSMOFF:
2581          return &elf32_frv_howto_table[ (int) R_FRV_TLSMOFF];
2582    
2583      case BFD_RELOC_VTABLE_INHERIT:      case BFD_RELOC_VTABLE_INHERIT:
2584        return &elf32_frv_vtinherit_howto;        return &elf32_frv_vtinherit_howto;
2585    
# Line 579  frv_reloc_type_lookup (abfd, code) Line 2594  frv_reloc_type_lookup (abfd, code)
2594    
2595  static void  static void
2596  frv_info_to_howto_rela (abfd, cache_ptr, dst)  frv_info_to_howto_rela (abfd, cache_ptr, dst)
2597       bfd * abfd ATTRIBUTE_UNUSED;       bfd *abfd ATTRIBUTE_UNUSED;
2598       arelent * cache_ptr;       arelent *cache_ptr;
2599       Elf32_Internal_Rela * dst;       Elf_Internal_Rela *dst;
2600  {  {
2601    unsigned int r_type;    unsigned int r_type;
2602    
# Line 601  frv_info_to_howto_rela (abfd, cache_ptr, Line 2616  frv_info_to_howto_rela (abfd, cache_ptr,
2616        break;        break;
2617      }      }
2618  }  }
2619    
2620    /* Set the howto pointer for an FRV ELF REL reloc.  */
2621    static void
2622    frvfdpic_info_to_howto_rel (bfd *abfd ATTRIBUTE_UNUSED,
2623                                arelent *cache_ptr, Elf_Internal_Rela *dst)
2624    {
2625      unsigned int r_type;
2626    
2627      r_type = ELF32_R_TYPE (dst->r_info);
2628      switch (r_type)
2629        {
2630        case R_FRV_32:
2631          cache_ptr->howto = &elf32_frv_rel_32_howto;
2632          break;
2633    
2634        case R_FRV_FUNCDESC:
2635          cache_ptr->howto = &elf32_frv_rel_funcdesc_howto;
2636          break;
2637    
2638        case R_FRV_FUNCDESC_VALUE:
2639          cache_ptr->howto = &elf32_frv_rel_funcdesc_value_howto;
2640          break;
2641    
2642        case R_FRV_TLSDESC_VALUE:
2643          cache_ptr->howto = &elf32_frv_rel_tlsdesc_value_howto;
2644          break;
2645    
2646        case R_FRV_TLSOFF:
2647          cache_ptr->howto = &elf32_frv_rel_tlsoff_howto;
2648          break;
2649    
2650        default:
2651          cache_ptr->howto = NULL;
2652          break;
2653        }
2654    }
2655    
2656  /* Perform a single relocation.  By default we use the standard BFD  /* Perform a single relocation.  By default we use the standard BFD
2657     routines, but a few relocs, we have to do them ourselves.  */     routines, but a few relocs, we have to do them ourselves.  */
2658    
2659  static bfd_reloc_status_type  static bfd_reloc_status_type
2660  frv_final_link_relocate (howto, input_bfd, input_section, contents, rel, relocation)  frv_final_link_relocate (howto, input_bfd, input_section, contents, rel,
2661       reloc_howto_type *  howto;                           relocation)
2662       bfd *               input_bfd;       reloc_howto_type *howto;
2663       asection *          input_section;       bfd *input_bfd;
2664       bfd_byte *          contents;       asection *input_section;
2665       Elf_Internal_Rela * rel;       bfd_byte *contents;
2666       bfd_vma             relocation;       Elf_Internal_Rela *rel;
2667         bfd_vma relocation;
2668  {  {
2669    return _bfd_final_link_relocate (howto, input_bfd, input_section,    return _bfd_final_link_relocate (howto, input_bfd, input_section,
2670                                     contents, rel->r_offset, relocation,                                     contents, rel->r_offset, relocation,
# Line 621  frv_final_link_relocate (howto, input_bf Line 2673  frv_final_link_relocate (howto, input_bf
2673    
2674    
2675  /* Relocate an FRV ELF section.  /* Relocate an FRV ELF section.
    There is some attempt to make this function usable for many architectures,  
    both USE_REL and USE_RELA ['twould be nice if such a critter existed],  
    if only to serve as a learning tool.  
2676    
2677     The RELOCATE_SECTION function is called by the new ELF backend linker     The RELOCATE_SECTION function is called by the new ELF backend linker
2678     to handle the relocations for a section.     to handle the relocations for a section.
# Line 633  frv_final_link_relocate (howto, input_bf Line 2682  frv_final_link_relocate (howto, input_bf
2682     zero.     zero.
2683    
2684     This function is responsible for adjusting the section contents as     This function is responsible for adjusting the section contents as
2685     necessary, and (if using Rela relocs and generating a relocateable     necessary, and (if using Rela relocs and generating a relocatable
2686     output file) adjusting the reloc addend as necessary.     output file) adjusting the reloc addend as necessary.
2687    
2688     This function does not have to worry about setting the reloc     This function does not have to worry about setting the reloc
# Line 647  frv_final_link_relocate (howto, input_bf Line 2696  frv_final_link_relocate (howto, input_bf
2696     The global hash table entry for the global symbols can be found     The global hash table entry for the global symbols can be found
2697     via elf_sym_hashes (input_bfd).     via elf_sym_hashes (input_bfd).
2698    
2699     When generating relocateable output, this function must handle     When generating relocatable output, this function must handle
2700     STB_LOCAL/STT_SECTION symbols specially.  The output symbol is     STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
2701     going to be the section symbol corresponding to the output     going to be the section symbol corresponding to the output
2702     section, which means that the addend must be adjusted     section, which means that the addend must be adjusted
2703     accordingly.  */     accordingly.  */
2704    
2705  static boolean  static bfd_boolean
2706  elf32_frv_relocate_section (output_bfd, info, input_bfd, input_section,  elf32_frv_relocate_section (output_bfd, info, input_bfd, input_section,
2707                             contents, relocs, local_syms, local_sections)                              contents, relocs, local_syms, local_sections)
2708       bfd *                   output_bfd ATTRIBUTE_UNUSED;       bfd *output_bfd ATTRIBUTE_UNUSED;
2709       struct bfd_link_info *  info;       struct bfd_link_info *info;
2710       bfd *                   input_bfd;       bfd *input_bfd;
2711       asection *              input_section;       asection *input_section;
2712       bfd_byte *              contents;       bfd_byte *contents;
2713       Elf_Internal_Rela *     relocs;       Elf_Internal_Rela *relocs;
2714       Elf_Internal_Sym *      local_syms;       Elf_Internal_Sym *local_syms;
2715       asection **             local_sections;       asection **local_sections;
2716  {  {
2717    Elf_Internal_Shdr *           symtab_hdr;    Elf_Internal_Shdr *symtab_hdr;
2718    struct elf_link_hash_entry ** sym_hashes;    struct elf_link_hash_entry **sym_hashes;
2719    Elf_Internal_Rela *           rel;    Elf_Internal_Rela *rel;
2720    Elf_Internal_Rela *           relend;    Elf_Internal_Rela *relend;
2721      unsigned isec_segment, got_segment, plt_segment, gprel_segment, tls_segment,
2722        check_segment[2];
2723      int silence_segment_error = !(info->shared || info->pie);
2724      unsigned long insn;
2725    
2726      if (info->relocatable)
2727        return TRUE;
2728    
2729    symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;    symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
2730    sym_hashes = elf_sym_hashes (input_bfd);    sym_hashes = elf_sym_hashes (input_bfd);
2731    relend     = relocs + input_section->reloc_count;    relend     = relocs + input_section->reloc_count;
2732    
2733      isec_segment = _frvfdpic_osec_to_segment (output_bfd,
2734                                                input_section->output_section);
2735      if (IS_FDPIC (output_bfd) && frvfdpic_got_section (info))
2736        got_segment = _frvfdpic_osec_to_segment (output_bfd,
2737                                                 frvfdpic_got_section (info)
2738                                                 ->output_section);
2739      else
2740        got_segment = -1;
2741      if (IS_FDPIC (output_bfd) && frvfdpic_gotfixup_section (info))
2742        gprel_segment = _frvfdpic_osec_to_segment (output_bfd,
2743                                                   frvfdpic_gotfixup_section (info)
2744                                                   ->output_section);
2745      else
2746        gprel_segment = -1;
2747      if (IS_FDPIC (output_bfd) && frvfdpic_plt_section (info))
2748        plt_segment = _frvfdpic_osec_to_segment (output_bfd,
2749                                                 frvfdpic_plt_section (info)
2750                                                 ->output_section);
2751      else
2752        plt_segment = -1;
2753      if (elf_hash_table (info)->tls_sec)
2754        tls_segment = _frvfdpic_osec_to_segment (output_bfd,
2755                                                 elf_hash_table (info)->tls_sec);
2756      else
2757        tls_segment = -1;
2758    
2759    for (rel = relocs; rel < relend; rel ++)    for (rel = relocs; rel < relend; rel ++)
2760      {      {
2761        reloc_howto_type *           howto;        reloc_howto_type *howto;
2762        unsigned long                r_symndx;        unsigned long r_symndx;
2763        Elf_Internal_Sym *           sym;        Elf_Internal_Sym *sym;
2764        asection *                   sec;        asection *sec;
2765        struct elf_link_hash_entry * h;        struct elf_link_hash_entry *h;
2766        bfd_vma                      relocation;        bfd_vma relocation;
2767        bfd_reloc_status_type        r;        bfd_reloc_status_type r;
2768        const char *                 name = NULL;        const char * name = NULL;
2769        int                          r_type;        int r_type;
2770                asection *osec;
2771          struct frvfdpic_relocs_info *picrel;
2772          bfd_vma orig_addend = rel->r_addend;
2773    
2774        r_type = ELF32_R_TYPE (rel->r_info);        r_type = ELF32_R_TYPE (rel->r_info);
2775          
2776        if (   r_type == R_FRV_GNU_VTINHERIT        if (   r_type == R_FRV_GNU_VTINHERIT
2777            || r_type == R_FRV_GNU_VTENTRY)            || r_type == R_FRV_GNU_VTENTRY)
2778          continue;          continue;
         
       r_symndx = ELF32_R_SYM (rel->r_info);  
   
       if (info->relocateable)  
         {  
           /* This is a relocateable link.  We don't have to change  
              anything, unless the reloc is against a section symbol,  
              in which case we have to adjust according to where the  
              section symbol winds up in the output section.  */  
           if (r_symndx < symtab_hdr->sh_info)  
             {  
               sym = local_syms + r_symndx;  
                 
               if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)  
                 {  
                   sec = local_sections [r_symndx];  
                   rel->r_addend += sec->output_offset + sym->st_value;  
                 }  
             }  
   
           continue;  
         }  
2779    
2780        /* This is a final link.  */        /* This is a final link.  */
2781          r_symndx = ELF32_R_SYM (rel->r_info);
2782        howto  = elf32_frv_howto_table + ELF32_R_TYPE (rel->r_info);        howto  = elf32_frv_howto_table + ELF32_R_TYPE (rel->r_info);
2783        h      = NULL;        h      = NULL;
2784        sym    = NULL;        sym    = NULL;
2785        sec    = NULL;        sec    = NULL;
2786          
2787        if (r_symndx < symtab_hdr->sh_info)        if (r_symndx < symtab_hdr->sh_info)
2788          {          {
2789            sym = local_syms + r_symndx;            sym = local_syms + r_symndx;
2790            sec = local_sections [r_symndx];            osec = sec = local_sections [r_symndx];
2791            relocation = (sec->output_section->vma            relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
2792                          + sec->output_offset  
                         + sym->st_value);  
             
2793            name = bfd_elf_string_from_elf_section            name = bfd_elf_string_from_elf_section
2794              (input_bfd, symtab_hdr->sh_link, sym->st_name);              (input_bfd, symtab_hdr->sh_link, sym->st_name);
2795            name = (name == NULL) ? bfd_section_name (input_bfd, sec) : name;            name = (name == NULL) ? bfd_section_name (input_bfd, sec) : name;
# Line 735  elf32_frv_relocate_section (output_bfd, Line 2797  elf32_frv_relocate_section (output_bfd,
2797        else        else
2798          {          {
2799            h = sym_hashes [r_symndx - symtab_hdr->sh_info];            h = sym_hashes [r_symndx - symtab_hdr->sh_info];
2800              
2801            while (h->root.type == bfd_link_hash_indirect            while (h->root.type == bfd_link_hash_indirect
2802                   || h->root.type == bfd_link_hash_warning)                   || h->root.type == bfd_link_hash_warning)
2803              h = (struct elf_link_hash_entry *) h->root.u.i.link;              h = (struct elf_link_hash_entry *) h->root.u.i.link;
2804    
2805            name = h->root.root.string;            name = h->root.root.string;
2806              
2807            if (h->root.type == bfd_link_hash_defined            if ((h->root.type == bfd_link_hash_defined
2808                || h->root.type == bfd_link_hash_defweak)                 || h->root.type == bfd_link_hash_defweak))
2809              {              {
2810                sec = h->root.u.def.section;                if (/* TLSMOFF forces local binding.  */
2811                relocation = (h->root.u.def.value                    r_type != R_FRV_TLSMOFF
2812                              + sec->output_section->vma                    && ! FRVFDPIC_SYM_LOCAL (info, h))
2813                              + sec->output_offset);                  {
2814                      sec = NULL;
2815                      relocation = 0;
2816                    }
2817                  else
2818                    {
2819                      sec = h->root.u.def.section;
2820                      relocation = (h->root.u.def.value
2821                                    + sec->output_section->vma
2822                                    + sec->output_offset);
2823                    }
2824              }              }
2825            else if (h->root.type == bfd_link_hash_undefweak)            else if (h->root.type == bfd_link_hash_undefweak)
2826              {              {
2827                relocation = 0;                relocation = 0;
2828              }              }
2829              else if (info->unresolved_syms_in_objects == RM_IGNORE
2830                       && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
2831                relocation = 0;
2832            else            else
2833              {              {
2834                if (! ((*info->callbacks->undefined_symbol)                if (! ((*info->callbacks->undefined_symbol)
2835                       (info, h->root.root.string, input_bfd,                       (info, h->root.root.string, input_bfd,
2836                        input_section, rel->r_offset, true)))                        input_section, rel->r_offset,
2837                  return false;                        (info->unresolved_syms_in_objects == RM_GENERATE_ERROR
2838                           || ELF_ST_VISIBILITY (h->other)))))
2839                    return FALSE;
2840                relocation = 0;                relocation = 0;
2841              }              }
2842              osec = sec;
2843          }          }
2844          
2845          switch (r_type)
2846            {
2847            case R_FRV_LABEL24:
2848            case R_FRV_32:
2849              if (! IS_FDPIC (output_bfd))
2850                goto non_fdpic;
2851    
2852            case R_FRV_GOT12:
2853            case R_FRV_GOTHI:
2854            case R_FRV_GOTLO:
2855            case R_FRV_FUNCDESC_GOT12:
2856            case R_FRV_FUNCDESC_GOTHI:
2857            case R_FRV_FUNCDESC_GOTLO:
2858            case R_FRV_GOTOFF12:
2859            case R_FRV_GOTOFFHI:
2860            case R_FRV_GOTOFFLO:
2861            case R_FRV_FUNCDESC_GOTOFF12:
2862            case R_FRV_FUNCDESC_GOTOFFHI:
2863            case R_FRV_FUNCDESC_GOTOFFLO:
2864            case R_FRV_FUNCDESC:
2865            case R_FRV_FUNCDESC_VALUE:
2866            case R_FRV_GETTLSOFF:
2867            case R_FRV_TLSDESC_VALUE:
2868            case R_FRV_GOTTLSDESC12:
2869            case R_FRV_GOTTLSDESCHI:
2870            case R_FRV_GOTTLSDESCLO:
2871            case R_FRV_TLSMOFF12:
2872            case R_FRV_TLSMOFFHI:
2873            case R_FRV_TLSMOFFLO:
2874            case R_FRV_GOTTLSOFF12:
2875            case R_FRV_GOTTLSOFFHI:
2876            case R_FRV_GOTTLSOFFLO:
2877            case R_FRV_TLSOFF:
2878            case R_FRV_TLSDESC_RELAX:
2879            case R_FRV_GETTLSOFF_RELAX:
2880            case R_FRV_TLSOFF_RELAX:
2881            case R_FRV_TLSMOFF:
2882              if (h != NULL)
2883                picrel = frvfdpic_relocs_info_for_global (frvfdpic_relocs_info
2884                                                          (info), input_bfd, h,
2885                                                          orig_addend, INSERT);
2886              else
2887                /* In order to find the entry we created before, we must
2888                   use the original addend, not the one that may have been
2889                   modified by _bfd_elf_rela_local_sym().  */
2890                picrel = frvfdpic_relocs_info_for_local (frvfdpic_relocs_info
2891                                                         (info), input_bfd, r_symndx,
2892                                                         orig_addend, INSERT);
2893              if (! picrel)
2894                return FALSE;
2895    
2896              if (!_frvfdpic_emit_got_relocs_plt_entries (picrel, output_bfd, info,
2897                                                          osec, sym,
2898                                                          rel->r_addend))
2899                {
2900                  (*_bfd_error_handler)
2901                    (_("%B(%A+0x%x): relocation to `%s+%x' may have caused the error above"),
2902                     input_bfd, input_section, rel->r_offset, name, rel->r_addend);
2903                  return FALSE;
2904                }
2905    
2906              break;
2907    
2908            default:
2909            non_fdpic:
2910              picrel = NULL;
2911              if (h && ! FRVFDPIC_SYM_LOCAL (info, h))
2912                {
2913                  info->callbacks->warning
2914                    (info, _("relocation references symbol not defined in the module"),
2915                     name, input_bfd, input_section, rel->r_offset);
2916                  return FALSE;
2917                }
2918              break;
2919            }
2920    
2921          switch (r_type)
2922            {
2923            case R_FRV_GETTLSOFF:
2924            case R_FRV_TLSDESC_VALUE:
2925            case R_FRV_GOTTLSDESC12:
2926            case R_FRV_GOTTLSDESCHI:
2927            case R_FRV_GOTTLSDESCLO:
2928            case R_FRV_TLSMOFF12:
2929            case R_FRV_TLSMOFFHI:
2930            case R_FRV_TLSMOFFLO:
2931            case R_FRV_GOTTLSOFF12:
2932            case R_FRV_GOTTLSOFFHI:
2933            case R_FRV_GOTTLSOFFLO:
2934            case R_FRV_TLSOFF:
2935            case R_FRV_TLSDESC_RELAX:
2936            case R_FRV_GETTLSOFF_RELAX:
2937            case R_FRV_TLSOFF_RELAX:
2938            case R_FRV_TLSMOFF:
2939              if (sec && (bfd_is_abs_section (sec) || bfd_is_und_section (sec)))
2940                relocation += tls_biased_base (info);
2941              break;
2942    
2943            default:
2944              break;
2945            }
2946    
2947          /* Try to apply TLS relaxations.  */
2948          if (1)
2949            switch (r_type)
2950              {
2951    
2952    #define LOCAL_EXEC_P(info, picrel) \
2953      ((info)->executable \
2954       && (picrel->symndx != -1 || FRVFDPIC_SYM_LOCAL ((info), (picrel)->d.h)))
2955    #define INITIAL_EXEC_P(info, picrel) \
2956      (((info)->executable || (info)->flags & DF_STATIC_TLS) \
2957       && (picrel)->tlsoff_entry)
2958    
2959    #define IN_RANGE_FOR_OFST12_P(value) \
2960      ((bfd_vma)((value) + 2048) < (bfd_vma)4096)
2961    #define IN_RANGE_FOR_SETLOS_P(value) \
2962      ((bfd_vma)((value) + 32768) < (bfd_vma)65536)
2963    #define TLSMOFF_IN_RANGE_FOR_SETLOS_P(value, info) \
2964      (IN_RANGE_FOR_SETLOS_P ((value) - tls_biased_base (info)))
2965    
2966    #define RELAX_GETTLSOFF_LOCAL_EXEC_P(info, picrel, value) \
2967      (LOCAL_EXEC_P ((info), (picrel)) \
2968       && TLSMOFF_IN_RANGE_FOR_SETLOS_P((value), (info)))
2969    #define RELAX_GETTLSOFF_INITIAL_EXEC_P(info, picrel) \
2970      (INITIAL_EXEC_P ((info), (picrel)) \
2971       && IN_RANGE_FOR_OFST12_P ((picrel)->tlsoff_entry))
2972    
2973    #define RELAX_TLSDESC_LOCAL_EXEC_P(info, picrel, value) \
2974      (LOCAL_EXEC_P ((info), (picrel)))
2975    #define RELAX_TLSDESC_INITIAL_EXEC_P(info, picrel) \
2976      (INITIAL_EXEC_P ((info), (picrel)))
2977    
2978    #define RELAX_GOTTLSOFF_LOCAL_EXEC_P(info, picrel, value) \
2979      (LOCAL_EXEC_P ((info), (picrel)) \
2980       && TLSMOFF_IN_RANGE_FOR_SETLOS_P((value), (info)))
2981    
2982              case R_FRV_GETTLSOFF:
2983                insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
2984    
2985                /* Is this a call instruction?  */
2986                if ((insn & (unsigned long)0x01fc0000) != 0x003c0000)
2987                  {
2988                    r = info->callbacks->warning
2989                      (info,
2990                       _("R_FRV_GETTLSOFF not applied to a call instruction"),
2991                       name, input_bfd, input_section, rel->r_offset);
2992                    return FALSE;
2993                  }
2994                
2995                if (RELAX_GETTLSOFF_LOCAL_EXEC_P (info, picrel,
2996                                                  relocation + rel->r_addend))
2997                  {
2998                    /* Replace the call instruction (except the packing bit)
2999                       with setlos #tlsmofflo(symbol+offset), gr9.  */
3000                    insn &= (unsigned long)0x80000000;
3001                    insn |= (unsigned long)0x12fc0000;
3002                    bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3003    
3004                    r_type = R_FRV_TLSMOFFLO;
3005                    howto  = elf32_frv_howto_table + r_type;
3006                    rel->r_info = ELF32_R_INFO (r_symndx, r_type);
3007                  }
3008    
3009                else if (RELAX_GETTLSOFF_INITIAL_EXEC_P (info, picrel))
3010                  {
3011                    /* Replace the call instruction (except the packing bit)
3012                       with ldi @(gr15, #gottlsoff12(symbol+addend)), gr9.  */
3013                    insn &= (unsigned long)0x80000000;
3014                    insn |= (unsigned long)0x12c8f000;
3015                    bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3016    
3017                    r_type = R_FRV_GOTTLSOFF12;
3018                    howto  = elf32_frv_howto_table + r_type;
3019                    rel->r_info = ELF32_R_INFO (r_symndx, r_type);
3020                  }
3021    
3022                break;
3023    
3024              case R_FRV_GOTTLSDESC12:
3025                insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3026    
3027                /* Is this an lddi instruction?  */
3028                if ((insn & (unsigned long)0x01fc0000) != 0x00cc0000)
3029                  {
3030                    r = info->callbacks->warning
3031                      (info,
3032                       _("R_FRV_GOTTLSDESC12 not applied to an lddi instruction"),
3033                       name, input_bfd, input_section, rel->r_offset);
3034                    return FALSE;
3035                  }
3036    
3037                if (RELAX_TLSDESC_LOCAL_EXEC_P (info, picrel,
3038                                                relocation + rel->r_addend)
3039                    && TLSMOFF_IN_RANGE_FOR_SETLOS_P (relocation + rel->r_addend,
3040                                                      info))
3041                  {
3042                    /* Replace lddi @(grB, #gottlsdesc12(symbol+offset), grC
3043                       with setlos #tlsmofflo(symbol+offset), gr<C+1>.
3044                       Preserve the packing bit.  */
3045                    insn = (insn & (unsigned long)0x80000000)
3046                      | ((insn + (unsigned long)0x02000000)
3047                         & (unsigned long)0x7e000000);
3048                    insn |= (unsigned long)0x00fc0000;
3049                    bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3050    
3051                    r_type = R_FRV_TLSMOFFLO;
3052                    howto  = elf32_frv_howto_table + r_type;
3053                    rel->r_info = ELF32_R_INFO (r_symndx, r_type);
3054                  }
3055    
3056                else if (RELAX_TLSDESC_LOCAL_EXEC_P (info, picrel,
3057                                                     relocation + rel->r_addend))
3058                  {
3059                    /* Replace lddi @(grB, #gottlsdesc12(symbol+offset), grC
3060                       with sethi #tlsmoffhi(symbol+offset), gr<C+1>.
3061                       Preserve the packing bit.  */
3062                    insn = (insn & (unsigned long)0x80000000)
3063                      | ((insn + (unsigned long)0x02000000)
3064                         & (unsigned long)0x7e000000);
3065                    insn |= (unsigned long)0x00f80000;
3066                    bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3067    
3068                    r_type = R_FRV_TLSMOFFHI;
3069                    howto  = elf32_frv_howto_table + r_type;
3070                    rel->r_info = ELF32_R_INFO (r_symndx, r_type);
3071                  }
3072    
3073                else if (RELAX_TLSDESC_INITIAL_EXEC_P (info, picrel))
3074                  {
3075                    /* Replace lddi @(grB, #gottlsdesc12(symbol+offset), grC
3076                       with ldi @(grB, #gottlsoff12(symbol+offset),
3077                       gr<C+1>.  Preserve the packing bit.  If gottlsoff12
3078                       overflows, we'll error out, but that's sort-of ok,
3079                       since we'd started with gottlsdesc12, that's actually
3080                       more demanding.  Compiling with -fPIE instead of
3081                       -fpie would fix it; linking with --relax should fix
3082                       it as well.  */
3083                    insn = (insn & (unsigned long)0x80cbf000)
3084                      | ((insn + (unsigned long)0x02000000)
3085                         & (unsigned long)0x7e000000);
3086                    bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3087    
3088                    r_type = R_FRV_GOTTLSOFF12;
3089                    howto  = elf32_frv_howto_table + r_type;
3090                    rel->r_info = ELF32_R_INFO (r_symndx, r_type);
3091                  }
3092    
3093                break;
3094    
3095              case R_FRV_GOTTLSDESCHI:
3096                insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3097    
3098                /* Is this a sethi instruction?  */
3099                if ((insn & (unsigned long)0x01ff0000) != 0x00f80000)
3100                  {
3101                    r = info->callbacks->warning
3102                      (info,
3103                       _("R_FRV_GOTTLSDESCHI not applied to a sethi instruction"),
3104                       name, input_bfd, input_section, rel->r_offset);
3105                    return FALSE;
3106                  }
3107    
3108                if (RELAX_TLSDESC_LOCAL_EXEC_P (info, picrel,
3109                                                relocation + rel->r_addend)
3110                    || (RELAX_TLSDESC_INITIAL_EXEC_P (info, picrel)
3111                        && IN_RANGE_FOR_SETLOS_P (picrel->tlsoff_entry)))
3112                  {
3113                    /* Replace sethi with a nop.  Preserve the packing bit.  */
3114                    insn &= (unsigned long)0x80000000;
3115                    insn |= (unsigned long)0x00880000;
3116                    bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3117    
3118                    /* Nothing to relocate.  */
3119                    continue;
3120                  }
3121    
3122                else if (RELAX_TLSDESC_INITIAL_EXEC_P (info, picrel))
3123                  {
3124                    /* Simply decay GOTTLSDESC to GOTTLSOFF.  */
3125                    r_type = R_FRV_GOTTLSOFFHI;
3126                    howto  = elf32_frv_howto_table + r_type;
3127                    rel->r_info = ELF32_R_INFO (r_symndx, r_type);
3128                  }
3129    
3130                break;
3131                
3132              case R_FRV_GOTTLSDESCLO:
3133                insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3134    
3135                /* Is this a setlo or setlos instruction?  */
3136                if ((insn & (unsigned long)0x01f70000) != 0x00f40000)
3137                  {
3138                    r = info->callbacks->warning
3139                      (info,
3140                       _("R_FRV_GOTTLSDESCLO"
3141                         " not applied to a setlo or setlos instruction"),
3142                       name, input_bfd, input_section, rel->r_offset);
3143                    return FALSE;
3144                  }
3145    
3146                if (RELAX_TLSDESC_LOCAL_EXEC_P (info, picrel,
3147                                                relocation + rel->r_addend)
3148                    || (RELAX_TLSDESC_INITIAL_EXEC_P (info, picrel)
3149                        && IN_RANGE_FOR_OFST12_P (picrel->tlsoff_entry)))
3150                  {
3151                    /* Replace setlo/setlos with a nop.  Preserve the
3152                       packing bit.  */
3153                    insn &= (unsigned long)0x80000000;
3154                    insn |= (unsigned long)0x00880000;
3155                    bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3156    
3157                    /* Nothing to relocate.  */
3158                    continue;
3159                  }
3160    
3161                else if (RELAX_TLSDESC_INITIAL_EXEC_P (info, picrel))
3162                  {
3163                    /* If the corresponding sethi (if it exists) decayed
3164                       to a nop, make sure this becomes (or already is) a
3165                       setlos, not setlo.  */
3166                    if (IN_RANGE_FOR_SETLOS_P (picrel->tlsoff_entry))
3167                      {
3168                        insn |= (unsigned long)0x00080000;
3169                        bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3170                      }
3171    
3172                    /* Simply decay GOTTLSDESC to GOTTLSOFF.  */
3173                    r_type = R_FRV_GOTTLSOFFLO;
3174                    howto  = elf32_frv_howto_table + r_type;
3175                    rel->r_info = ELF32_R_INFO (r_symndx, r_type);
3176                  }
3177    
3178                break;
3179                
3180              case R_FRV_TLSDESC_RELAX:
3181                insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3182    
3183                /* Is this an ldd instruction?  */
3184                if ((insn & (unsigned long)0x01fc0fc0) != 0x00080140)
3185                  {
3186                    r = info->callbacks->warning
3187                      (info,
3188                       _("R_FRV_TLSDESC_RELAX not applied to an ldd instruction"),
3189                       name, input_bfd, input_section, rel->r_offset);
3190                    return FALSE;
3191                  }
3192    
3193                if (RELAX_TLSDESC_LOCAL_EXEC_P (info, picrel,
3194                                                relocation + rel->r_addend)
3195                    && TLSMOFF_IN_RANGE_FOR_SETLOS_P (relocation + rel->r_addend,
3196                                                      info))
3197                  {
3198                    /* Replace ldd #tlsdesc(symbol+offset)@(grB, grA), grC
3199                       with setlos #tlsmofflo(symbol+offset), gr<C+1>.
3200                       Preserve the packing bit.  */
3201                    insn = (insn & (unsigned long)0x80000000)
3202                      | ((insn + (unsigned long)0x02000000)
3203                         & (unsigned long)0x7e000000);
3204                    insn |= (unsigned long)0x00fc0000;
3205                    bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3206    
3207                    r_type = R_FRV_TLSMOFFLO;
3208                    howto  = elf32_frv_howto_table + r_type;
3209                    rel->r_info = ELF32_R_INFO (r_symndx, r_type);
3210                  }
3211    
3212                else if (RELAX_TLSDESC_LOCAL_EXEC_P (info, picrel,
3213                                                     relocation + rel->r_addend))
3214                  {
3215                    /* Replace ldd #tlsdesc(symbol+offset)@(grB, grA), grC
3216                       with sethi #tlsmoffhi(symbol+offset), gr<C+1>.
3217                       Preserve the packing bit.  */
3218                    insn = (insn & (unsigned long)0x80000000)
3219                      | ((insn + (unsigned long)0x02000000)
3220                         & (unsigned long)0x7e000000);
3221                    insn |= (unsigned long)0x00f80000;
3222                    bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3223    
3224                    r_type = R_FRV_TLSMOFFHI;
3225                    howto  = elf32_frv_howto_table + r_type;
3226                    rel->r_info = ELF32_R_INFO (r_symndx, r_type);
3227                  }
3228    
3229                else if (RELAX_TLSDESC_INITIAL_EXEC_P (info, picrel)
3230                         && IN_RANGE_FOR_OFST12_P (picrel->tlsoff_entry))
3231                  {
3232                    /* Replace ldd #tlsdesc(symbol+offset)@(grB, grA), grC
3233                       with ldi @(grB, #gottlsoff12(symbol+offset), gr<C+1>.
3234                       Preserve the packing bit.  */
3235                    insn = (insn & (unsigned long)0x8003f000)
3236                      | (unsigned long)0x00c80000
3237                      | ((insn + (unsigned long)0x02000000)
3238                         & (unsigned long)0x7e000000);
3239                    bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3240    
3241                    r_type = R_FRV_GOTTLSOFF12;
3242                    howto  = elf32_frv_howto_table + r_type;
3243                    rel->r_info = ELF32_R_INFO (r_symndx, r_type);
3244                  }
3245    
3246                else if (RELAX_TLSDESC_INITIAL_EXEC_P (info, picrel))
3247                  {
3248                    /* Replace ldd #tlsdesc(symbol+offset)@(grB, grA), grC
3249                       with ld #tlsoff(symbol+offset)@(grB, grA), gr<C+1>.
3250                       Preserve the packing bit.  */
3251                    insn = (insn & (unsigned long)0x81ffffbf)
3252                      | ((insn + (unsigned long)0x02000000)
3253                         & (unsigned long)0x7e000000);
3254                    bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3255    
3256                    /* #tlsoff(symbol+offset) is just a relaxation
3257                        annotation, so there's nothing left to
3258                        relocate.  */
3259                    continue;
3260                  }
3261    
3262                break;
3263    
3264              case R_FRV_GETTLSOFF_RELAX:
3265                insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3266    
3267                /* Is this a calll or callil instruction?  */
3268                if ((insn & (unsigned long)0x7ff80fc0) != 0x02300000)
3269                  {
3270                    r = info->callbacks->warning
3271                      (info,
3272                       _("R_FRV_GETTLSOFF_RELAX"
3273                         " not applied to a calll instruction"),
3274                       name, input_bfd, input_section, rel->r_offset);
3275                    return FALSE;
3276                  }
3277    
3278                if (RELAX_TLSDESC_LOCAL_EXEC_P (info, picrel,
3279                                                relocation + rel->r_addend)
3280                    && TLSMOFF_IN_RANGE_FOR_SETLOS_P (relocation + rel->r_addend,
3281                                                      info))
3282                  {
3283                    /* Replace calll with a nop.  Preserve the packing bit.  */
3284                    insn &= (unsigned long)0x80000000;
3285                    insn |= (unsigned long)0x00880000;
3286                    bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3287    
3288                    /* Nothing to relocate.  */
3289                    continue;
3290                  }
3291    
3292                else if (RELAX_TLSDESC_LOCAL_EXEC_P (info, picrel,
3293                                                     relocation + rel->r_addend))
3294                  {
3295                    /* Replace calll with setlo #tlsmofflo(symbol+offset), gr9.
3296                       Preserve the packing bit.  */
3297                    insn &= (unsigned long)0x80000000;
3298                    insn |= (unsigned long)0x12f40000;
3299                    bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3300    
3301                    r_type = R_FRV_TLSMOFFLO;
3302                    howto  = elf32_frv_howto_table + r_type;
3303                    rel->r_info = ELF32_R_INFO (r_symndx, r_type);
3304                  }
3305    
3306                else if (RELAX_TLSDESC_INITIAL_EXEC_P (info, picrel))
3307                  {
3308                    /* Replace calll with a nop.  Preserve the packing bit.  */
3309                    insn &= (unsigned long)0x80000000;
3310                    insn |= (unsigned long)0x00880000;
3311                    bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3312    
3313                    /* Nothing to relocate.  */
3314                    continue;
3315                  }
3316    
3317                break;
3318    
3319              case R_FRV_GOTTLSOFF12:
3320                insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3321    
3322                /* Is this an ldi instruction?  */
3323                if ((insn & (unsigned long)0x01fc0000) != 0x00c80000)
3324                  {
3325                    r = info->callbacks->warning
3326                      (info,
3327                       _("R_FRV_GOTTLSOFF12 not applied to an ldi instruction"),
3328                       name, input_bfd, input_section, rel->r_offset);
3329                    return FALSE;
3330                  }
3331    
3332                if (RELAX_GOTTLSOFF_LOCAL_EXEC_P (info, picrel,
3333                                                  relocation + rel->r_addend))
3334                  {
3335                    /* Replace ldi @(grB, #gottlsoff12(symbol+offset), grC
3336                       with setlos #tlsmofflo(symbol+offset), grC.
3337                       Preserve the packing bit.  */
3338                    insn &= (unsigned long)0xfe000000;
3339                    insn |= (unsigned long)0x00fc0000;
3340                    bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3341    
3342                    r_type = R_FRV_TLSMOFFLO;
3343                    howto  = elf32_frv_howto_table + r_type;
3344                    rel->r_info = ELF32_R_INFO (r_symndx, r_type);
3345                  }
3346    
3347                break;
3348    
3349              case R_FRV_GOTTLSOFFHI:
3350                insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3351    
3352                /* Is this a sethi instruction?  */
3353                if ((insn & (unsigned long)0x01ff0000) != 0x00f80000)
3354                  {
3355                    r = info->callbacks->warning
3356                      (info,
3357                       _("R_FRV_GOTTLSOFFHI not applied to a sethi instruction"),
3358                       name, input_bfd, input_section, rel->r_offset);
3359                    return FALSE;
3360                  }
3361    
3362                if (RELAX_GOTTLSOFF_LOCAL_EXEC_P (info, picrel,
3363                                                  relocation + rel->r_addend)
3364                    || (RELAX_TLSDESC_INITIAL_EXEC_P (info, picrel)
3365                        && IN_RANGE_FOR_OFST12_P (picrel->tlsoff_entry)))
3366                  {
3367                    /* Replace sethi with a nop.  Preserve the packing bit.  */
3368                    insn &= (unsigned long)0x80000000;
3369                    insn |= (unsigned long)0x00880000;
3370                    bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3371    
3372                    /* Nothing to relocate.  */
3373                    continue;
3374                  }
3375    
3376                break;
3377    
3378              case R_FRV_GOTTLSOFFLO:
3379                insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3380    
3381                /* Is this a setlo or setlos instruction?  */
3382                if ((insn & (unsigned long)0x01f70000) != 0x00f40000)
3383                  {
3384                    r = info->callbacks->warning
3385                      (info,
3386                       _("R_FRV_GOTTLSOFFLO"
3387                         " not applied to a setlo or setlos instruction"),
3388                       name, input_bfd, input_section, rel->r_offset);
3389                    return FALSE;
3390                  }
3391    
3392                if (RELAX_GOTTLSOFF_LOCAL_EXEC_P (info, picrel,
3393                                                  relocation + rel->r_addend)
3394                    || (RELAX_TLSDESC_INITIAL_EXEC_P (info, picrel)
3395                        && IN_RANGE_FOR_OFST12_P (picrel->tlsoff_entry)))
3396                  {
3397                    /* Replace setlo/setlos with a nop.  Preserve the
3398                       packing bit.  */
3399                    insn &= (unsigned long)0x80000000;
3400                    insn |= (unsigned long)0x00880000;
3401                    bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3402    
3403                    /* Nothing to relocate.  */
3404                    continue;
3405                  }
3406    
3407                break;
3408    
3409              case R_FRV_TLSOFF_RELAX:
3410                insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3411    
3412                /* Is this an ld instruction?  */
3413                if ((insn & (unsigned long)0x01fc0fc0) != 0x00080100)
3414                  {
3415                    r = info->callbacks->warning
3416                      (info,
3417                       _("R_FRV_TLSOFF_RELAX not applied to an ld instruction"),
3418                       name, input_bfd, input_section, rel->r_offset);
3419                    return FALSE;
3420                  }
3421    
3422                if (RELAX_GOTTLSOFF_LOCAL_EXEC_P (info, picrel,
3423                                                  relocation + rel->r_addend))
3424                  {
3425                    /* Replace ld #gottlsoff(symbol+offset)@(grB, grA), grC
3426                       with setlos #tlsmofflo(symbol+offset), grC.
3427                       Preserve the packing bit.  */
3428                    insn &= (unsigned long)0xfe000000;
3429                    insn |= (unsigned long)0x00fc0000;
3430                    bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3431    
3432                    r_type = R_FRV_TLSMOFFLO;
3433                    howto  = elf32_frv_howto_table + r_type;
3434                    rel->r_info = ELF32_R_INFO (r_symndx, r_type);
3435                  }
3436    
3437                else if (RELAX_TLSDESC_INITIAL_EXEC_P (info, picrel)
3438                         && IN_RANGE_FOR_OFST12_P (picrel->tlsoff_entry))
3439                  {
3440                    /* Replace ld #tlsoff(symbol+offset)@(grB, grA), grC
3441                       with ldi @(grB, #gottlsoff12(symbol+offset), grC.
3442                       Preserve the packing bit.  */
3443                    insn = (insn & (unsigned long)0xfe03f000)
3444                      | (unsigned long)0x00c80000;;
3445                    bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3446    
3447                    r_type = R_FRV_GOTTLSOFF12;
3448                    howto  = elf32_frv_howto_table + r_type;
3449                    rel->r_info = ELF32_R_INFO (r_symndx, r_type);
3450                  }
3451    
3452                break;
3453    
3454              case R_FRV_TLSMOFFHI:
3455                insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3456    
3457                /* Is this a sethi instruction?  */
3458                if ((insn & (unsigned long)0x01ff0000) != 0x00f80000)
3459                  {
3460                    r = info->callbacks->warning
3461                      (info,
3462                       _("R_FRV_TLSMOFFHI not applied to a sethi instruction"),
3463                       name, input_bfd, input_section, rel->r_offset);
3464                    return FALSE;
3465                  }
3466    
3467                if (TLSMOFF_IN_RANGE_FOR_SETLOS_P (relocation + rel->r_addend,
3468                                                   info))
3469                  {
3470                    /* Replace sethi with a nop.  Preserve the packing bit.  */
3471                    insn &= (unsigned long)0x80000000;
3472                    insn |= (unsigned long)0x00880000;
3473                    bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3474    
3475                    /* Nothing to relocate.  */
3476                    continue;
3477                  }
3478    
3479                break;
3480    
3481              case R_FRV_TLSMOFFLO:
3482                insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3483    
3484                /* Is this a setlo or setlos instruction?  */
3485                if ((insn & (unsigned long)0x01f70000) != 0x00f40000)
3486                  {
3487                    r = info->callbacks->warning
3488                      (info,
3489                       _("R_FRV_TLSMOFFLO"
3490                         " not applied to a setlo or setlos instruction"),
3491                       name, input_bfd, input_section, rel->r_offset);
3492                    return FALSE;
3493                  }
3494    
3495                if (TLSMOFF_IN_RANGE_FOR_SETLOS_P (relocation + rel->r_addend,
3496                                                   info))
3497                  /* If the corresponding sethi (if it exists) decayed
3498                     to a nop, make sure this becomes (or already is) a
3499                     setlos, not setlo.  */
3500                  {
3501                    insn |= (unsigned long)0x00080000;
3502                    bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3503                  }
3504    
3505                break;
3506    
3507                /*
3508                  There's nothing to relax in these:
3509                    R_FRV_TLSDESC_VALUE
3510                    R_FRV_TLSOFF
3511                    R_FRV_TLSMOFF12
3512                    R_FRV_TLSMOFFHI
3513                    R_FRV_TLSMOFFLO
3514                    R_FRV_TLSMOFF
3515                */
3516    
3517              default:
3518                break;
3519              }
3520    
3521          switch (r_type)
3522            {
3523            case R_FRV_LABEL24:
3524              check_segment[0] = isec_segment;
3525              if (! IS_FDPIC (output_bfd))
3526                check_segment[1] = isec_segment;
3527              else if (picrel->plt)
3528                {
3529                  relocation = frvfdpic_plt_section (info)->output_section->vma
3530                    + frvfdpic_plt_section (info)->output_offset
3531                    + picrel->plt_entry;
3532                  check_segment[1] = plt_segment;
3533                }
3534              /* We don't want to warn on calls to undefined weak symbols,
3535                 as calls to them must be protected by non-NULL tests
3536                 anyway, and unprotected calls would invoke undefined
3537                 behavior.  */
3538              else if (picrel->symndx == -1
3539                       && picrel->d.h->root.type == bfd_link_hash_undefweak)
3540                check_segment[1] = check_segment[0];
3541              else
3542                check_segment[1] = sec
3543                  ? _frvfdpic_osec_to_segment (output_bfd, sec->output_section)
3544                  : (unsigned)-1;
3545              break;
3546    
3547            case R_FRV_GOT12:
3548            case R_FRV_GOTHI:
3549            case R_FRV_GOTLO:
3550              relocation = picrel->got_entry;
3551              check_segment[0] = check_segment[1] = got_segment;
3552              break;
3553    
3554            case R_FRV_FUNCDESC_GOT12:
3555            case R_FRV_FUNCDESC_GOTHI:
3556            case R_FRV_FUNCDESC_GOTLO:
3557              relocation = picrel->fdgot_entry;
3558              check_segment[0] = check_segment[1] = got_segment;
3559              break;
3560    
3561            case R_FRV_GOTOFFHI:
3562            case R_FRV_GOTOFF12:
3563            case R_FRV_GOTOFFLO:
3564              relocation -= frvfdpic_got_section (info)->output_section->vma
3565                + frvfdpic_got_section (info)->output_offset
3566                + frvfdpic_got_initial_offset (info);
3567              check_segment[0] = got_segment;
3568              check_segment[1] = sec
3569                ? _frvfdpic_osec_to_segment (output_bfd, sec->output_section)
3570                : (unsigned)-1;
3571              break;
3572    
3573            case R_FRV_FUNCDESC_GOTOFF12:
3574            case R_FRV_FUNCDESC_GOTOFFHI:
3575            case R_FRV_FUNCDESC_GOTOFFLO:
3576              relocation = picrel->fd_entry;
3577              check_segment[0] = check_segment[1] = got_segment;
3578              break;
3579    
3580            case R_FRV_FUNCDESC:
3581              {
3582                int dynindx;
3583                bfd_vma addend = rel->r_addend;
3584    
3585                if (! (h && h->root.type == bfd_link_hash_undefweak
3586                       && FRVFDPIC_SYM_LOCAL (info, h)))
3587                  {
3588                    /* If the symbol is dynamic and there may be dynamic
3589                       symbol resolution because we are or are linked with a
3590                       shared library, emit a FUNCDESC relocation such that
3591                       the dynamic linker will allocate the function
3592                       descriptor.  If the symbol needs a non-local function
3593                       descriptor but binds locally (e.g., its visibility is
3594                       protected, emit a dynamic relocation decayed to
3595                       section+offset.  */
3596                    if (h && ! FRVFDPIC_FUNCDESC_LOCAL (info, h)
3597                        && FRVFDPIC_SYM_LOCAL (info, h)
3598                        && !(info->executable && !info->pie))
3599                      {
3600                        dynindx = elf_section_data (h->root.u.def.section
3601                                                    ->output_section)->dynindx;
3602                        addend += h->root.u.def.section->output_offset
3603                          + h->root.u.def.value;
3604                      }
3605                    else if (h && ! FRVFDPIC_FUNCDESC_LOCAL (info, h))
3606                      {
3607                        if (addend)
3608                          {
3609                            info->callbacks->warning
3610                              (info, _("R_FRV_FUNCDESC references dynamic symbol with nonzero addend"),
3611                               name, input_bfd, input_section, rel->r_offset);
3612                            return FALSE;
3613                          }
3614                        dynindx = h->dynindx;
3615                      }
3616                    else
3617                      {
3618                        /* Otherwise, we know we have a private function
3619                           descriptor, so reference it directly.  */
3620                        BFD_ASSERT (picrel->privfd);
3621                        r_type = R_FRV_32;
3622                        dynindx = elf_section_data (frvfdpic_got_section (info)
3623                                                    ->output_section)->dynindx;
3624                        addend = frvfdpic_got_section (info)->output_offset
3625                          + frvfdpic_got_initial_offset (info)
3626                          + picrel->fd_entry;
3627                      }
3628    
3629                    /* If there is room for dynamic symbol resolution, emit
3630                       the dynamic relocation.  However, if we're linking an
3631                       executable at a fixed location, we won't have emitted a
3632                       dynamic symbol entry for the got section, so idx will
3633                       be zero, which means we can and should compute the
3634                       address of the private descriptor ourselves.  */
3635                    if (info->executable && !info->pie
3636                        && (!h || FRVFDPIC_FUNCDESC_LOCAL (info, h)))
3637                      {
3638                        addend += frvfdpic_got_section (info)->output_section->vma;
3639                        if ((bfd_get_section_flags (output_bfd,
3640                                                    input_section->output_section)
3641                             & (SEC_ALLOC | SEC_LOAD)) == (SEC_ALLOC | SEC_LOAD))
3642                          {
3643                            if (_frvfdpic_osec_readonly_p (output_bfd,
3644                                                           input_section
3645                                                           ->output_section))
3646                              {
3647                                info->callbacks->warning
3648                                  (info,
3649                                   _("cannot emit fixups in read-only section"),
3650                                   name, input_bfd, input_section, rel->r_offset);
3651                                return FALSE;
3652                              }
3653                            _frvfdpic_add_rofixup (output_bfd,
3654                                                   frvfdpic_gotfixup_section
3655                                                   (info),
3656                                                   _bfd_elf_section_offset
3657                                                   (output_bfd, info,
3658                                                    input_section, rel->r_offset)
3659                                                   + input_section
3660                                                   ->output_section->vma
3661                                                   + input_section->output_offset,
3662                                                   picrel);
3663                          }
3664                      }
3665                    else if ((bfd_get_section_flags (output_bfd,
3666                                                     input_section->output_section)
3667                              & (SEC_ALLOC | SEC_LOAD)) == (SEC_ALLOC | SEC_LOAD))
3668                      {
3669                        if (_frvfdpic_osec_readonly_p (output_bfd,
3670                                                       input_section
3671                                                       ->output_section))
3672                          {
3673                            info->callbacks->warning
3674                              (info,
3675                               _("cannot emit dynamic relocations in read-only section"),
3676                               name, input_bfd, input_section, rel->r_offset);
3677                            return FALSE;
3678                          }
3679                        _frvfdpic_add_dyn_reloc (output_bfd,
3680                                                 frvfdpic_gotrel_section (info),
3681                                                 _bfd_elf_section_offset
3682                                                 (output_bfd, info,
3683                                                  input_section, rel->r_offset)
3684                                                 + input_section
3685                                                 ->output_section->vma
3686                                                 + input_section->output_offset,
3687                                                 r_type, dynindx, addend, picrel);
3688                      }
3689                    else
3690                      addend += frvfdpic_got_section (info)->output_section->vma;
3691                  }
3692    
3693                /* We want the addend in-place because dynamic
3694                   relocations are REL.  Setting relocation to it should
3695                   arrange for it to be installed.  */
3696                relocation = addend - rel->r_addend;
3697              }
3698              check_segment[0] = check_segment[1] = got_segment;
3699              break;
3700    
3701            case R_FRV_32:
3702              if (! IS_FDPIC (output_bfd))
3703                {
3704                  check_segment[0] = check_segment[1] = -1;
3705                  break;
3706                }
3707              /* Fall through.  */
3708            case R_FRV_FUNCDESC_VALUE:
3709              {
3710                int dynindx;
3711                bfd_vma addend = rel->r_addend;
3712    
3713                /* If the symbol is dynamic but binds locally, use
3714                   section+offset.  */
3715                if (h && ! FRVFDPIC_SYM_LOCAL (info, h))
3716                  {
3717                    if (addend && r_type == R_FRV_FUNCDESC_VALUE)
3718                      {
3719                        info->callbacks->warning
3720                          (info, _("R_FRV_FUNCDESC_VALUE references dynamic symbol with nonzero addend"),
3721                           name, input_bfd, input_section, rel->r_offset);
3722                        return FALSE;
3723                      }
3724                    dynindx = h->dynindx;
3725                  }
3726                else
3727                  {
3728                    if (h)
3729                      addend += h->root.u.def.value;
3730                    else
3731                      addend += sym->st_value;
3732                    if (osec)
3733                      addend += osec->output_offset;
3734                    if (osec && osec->output_section
3735                        && ! bfd_is_abs_section (osec->output_section)
3736                        && ! bfd_is_und_section (osec->output_section))
3737                      dynindx = elf_section_data (osec->output_section)->dynindx;
3738                    else
3739                      dynindx = 0;
3740                  }
3741    
3742                /* If we're linking an executable at a fixed address, we
3743                   can omit the dynamic relocation as long as the symbol
3744                   is defined in the current link unit (which is implied
3745                   by its output section not being NULL).  */
3746                if (info->executable && !info->pie
3747                    && (!h || FRVFDPIC_SYM_LOCAL (info, h)))
3748                  {
3749                    if (osec)
3750                      addend += osec->output_section->vma;
3751                    if (IS_FDPIC (input_bfd)
3752                        && (bfd_get_section_flags (output_bfd,
3753                                                   input_section->output_section)
3754                            & (SEC_ALLOC | SEC_LOAD)) == (SEC_ALLOC | SEC_LOAD))
3755                      {
3756                        if (_frvfdpic_osec_readonly_p (output_bfd,
3757                                                       input_section
3758                                                       ->output_section))
3759                          {
3760                            info->callbacks->warning
3761                              (info,
3762                               _("cannot emit fixups in read-only section"),
3763                               name, input_bfd, input_section, rel->r_offset);
3764                            return FALSE;
3765                          }
3766                        if (!h || h->root.type != bfd_link_hash_undefweak)
3767                          {
3768                            _frvfdpic_add_rofixup (output_bfd,
3769                                                   frvfdpic_gotfixup_section
3770                                                   (info),
3771                                                   _bfd_elf_section_offset
3772                                                   (output_bfd, info,
3773                                                    input_section, rel->r_offset)
3774                                                   + input_section
3775                                                   ->output_section->vma
3776                                                   + input_section->output_offset,
3777                                                   picrel);
3778                            if (r_type == R_FRV_FUNCDESC_VALUE)
3779                              _frvfdpic_add_rofixup
3780                                (output_bfd,
3781                                 frvfdpic_gotfixup_section (info),
3782                                 _bfd_elf_section_offset
3783                                 (output_bfd, info,
3784                                  input_section, rel->r_offset)
3785                                 + input_section->output_section->vma
3786                                 + input_section->output_offset + 4, picrel);
3787                          }
3788                      }
3789                  }
3790                else
3791                  {
3792                    if ((bfd_get_section_flags (output_bfd,
3793                                                input_section->output_section)
3794                         & (SEC_ALLOC | SEC_LOAD)) == (SEC_ALLOC | SEC_LOAD))
3795                      {
3796                        if (_frvfdpic_osec_readonly_p (output_bfd,
3797                                                       input_section
3798                                                       ->output_section))
3799                          {
3800                            info->callbacks->warning
3801                              (info,
3802                               _("cannot emit dynamic relocations in read-only section"),
3803                               name, input_bfd, input_section, rel->r_offset);
3804                            return FALSE;
3805                          }
3806                        _frvfdpic_add_dyn_reloc (output_bfd,
3807                                                 frvfdpic_gotrel_section (info),
3808                                                 _bfd_elf_section_offset
3809                                                 (output_bfd, info,
3810                                                  input_section, rel->r_offset)
3811                                                 + input_section
3812                                                 ->output_section->vma
3813                                                 + input_section->output_offset,
3814                                                 r_type, dynindx, addend, picrel);
3815                      }
3816                    else if (osec)
3817                      addend += osec->output_section->vma;
3818                    /* We want the addend in-place because dynamic
3819                       relocations are REL.  Setting relocation to it
3820                       should arrange for it to be installed.  */
3821                    relocation = addend - rel->r_addend;
3822                  }
3823    
3824                if (r_type == R_FRV_FUNCDESC_VALUE)
3825                  {
3826                    /* If we've omitted the dynamic relocation, just emit
3827                       the fixed addresses of the symbol and of the local
3828                       GOT base offset.  */
3829                    if (info->executable && !info->pie
3830                        && (!h || FRVFDPIC_SYM_LOCAL (info, h)))
3831                      bfd_put_32 (output_bfd,
3832                                  frvfdpic_got_section (info)->output_section->vma
3833                                  + frvfdpic_got_section (info)->output_offset
3834                                  + frvfdpic_got_initial_offset (info),
3835                                  contents + rel->r_offset + 4);
3836                    else
3837                      /* A function descriptor used for lazy or local
3838                         resolving is initialized such that its high word
3839                         contains the output section index in which the
3840                         PLT entries are located, and the low word
3841                         contains the offset of the lazy PLT entry entry
3842                         point into that section.  */
3843                      bfd_put_32 (output_bfd,
3844                                  h && ! FRVFDPIC_SYM_LOCAL (info, h)
3845                                  ? 0
3846                                  : _frvfdpic_osec_to_segment (output_bfd,
3847                                                               sec
3848                                                               ->output_section),
3849                                  contents + rel->r_offset + 4);
3850                  }
3851              }
3852              check_segment[0] = check_segment[1] = got_segment;
3853              break;
3854    
3855            case R_FRV_GPREL12:
3856            case R_FRV_GPRELU12:
3857            case R_FRV_GPREL32:
3858            case R_FRV_GPRELHI:
3859            case R_FRV_GPRELLO:
3860              check_segment[0] = gprel_segment;
3861              check_segment[1] = sec
3862                ? _frvfdpic_osec_to_segment (output_bfd, sec->output_section)
3863                : (unsigned)-1;
3864              break;
3865    
3866            case R_FRV_GETTLSOFF:
3867              relocation = frvfdpic_plt_section (info)->output_section->vma
3868                + frvfdpic_plt_section (info)->output_offset
3869                + picrel->tlsplt_entry;
3870              BFD_ASSERT (picrel->tlsplt_entry != (bfd_vma)-1
3871                          && picrel->tlsdesc_entry);
3872              check_segment[0] = isec_segment;
3873              check_segment[1] = plt_segment;
3874              break;
3875    
3876            case R_FRV_GOTTLSDESC12:
3877            case R_FRV_GOTTLSDESCHI:
3878            case R_FRV_GOTTLSDESCLO:
3879              BFD_ASSERT (picrel->tlsdesc_entry);
3880              relocation = picrel->tlsdesc_entry;
3881              check_segment[0] = tls_segment;
3882              check_segment[1] = sec
3883                && ! bfd_is_abs_section (sec)
3884                && ! bfd_is_und_section (sec)
3885                ? _frvfdpic_osec_to_segment (output_bfd, sec->output_section)
3886                : tls_segment;
3887              break;
3888    
3889            case R_FRV_TLSMOFF12:
3890            case R_FRV_TLSMOFFHI:
3891            case R_FRV_TLSMOFFLO:
3892            case R_FRV_TLSMOFF:
3893              check_segment[0] = tls_segment;
3894              if (! sec)
3895                check_segment[1] = -1;
3896              else if (bfd_is_abs_section (sec)
3897                       || bfd_is_und_section (sec))
3898                {
3899                  relocation = 0;
3900                  check_segment[1] = tls_segment;
3901                }
3902              else if (sec->output_section)
3903                {
3904                  relocation -= tls_biased_base (info);
3905                  check_segment[1] =
3906                    _frvfdpic_osec_to_segment (output_bfd, sec->output_section);
3907                }
3908              else
3909                check_segment[1] = -1;
3910              break;
3911    
3912            case R_FRV_GOTTLSOFF12:
3913            case R_FRV_GOTTLSOFFHI:
3914            case R_FRV_GOTTLSOFFLO:
3915              BFD_ASSERT (picrel->tlsoff_entry);
3916              relocation = picrel->tlsoff_entry;
3917              check_segment[0] = tls_segment;
3918              check_segment[1] = sec
3919                && ! bfd_is_abs_section (sec)
3920                && ! bfd_is_und_section (sec)
3921                ? _frvfdpic_osec_to_segment (output_bfd, sec->output_section)
3922                : tls_segment;
3923              break;
3924              
3925            case R_FRV_TLSDESC_VALUE:
3926            case R_FRV_TLSOFF:
3927              /* These shouldn't be present in input object files.  */
3928              check_segment[0] = check_segment[1] = isec_segment;
3929              break;
3930    
3931            case R_FRV_TLSDESC_RELAX:
3932            case R_FRV_GETTLSOFF_RELAX:
3933            case R_FRV_TLSOFF_RELAX:
3934              /* These are just annotations for relaxation, nothing to do
3935                 here.  */
3936              continue;
3937    
3938            default:
3939              check_segment[0] = isec_segment;
3940              check_segment[1] = sec
3941                ? _frvfdpic_osec_to_segment (output_bfd, sec->output_section)
3942                : (unsigned)-1;
3943              break;
3944            }
3945    
3946          if (check_segment[0] != check_segment[1] && IS_FDPIC (output_bfd))
3947            {
3948              /* If you take this out, remove the #error from fdpic-static-6.d
3949                 in the ld testsuite.  */
3950              /* This helps catch problems in GCC while we can't do more
3951                 than static linking.  The idea is to test whether the
3952                 input file basename is crt0.o only once.  */
3953              if (silence_segment_error == 1)
3954                silence_segment_error =
3955                  (strlen (input_bfd->filename) == 6
3956                   && strcmp (input_bfd->filename, "crt0.o") == 0)
3957                  || (strlen (input_bfd->filename) > 6
3958                      && strcmp (input_bfd->filename
3959                                 + strlen (input_bfd->filename) - 7,
3960                                 "/crt0.o") == 0)
3961                  ? -1 : 0;
3962              if (!silence_segment_error
3963                  /* We don't want duplicate errors for undefined
3964                     symbols.  */
3965                  && !(picrel && picrel->symndx == -1
3966                       && picrel->d.h->root.type == bfd_link_hash_undefined))
3967                {
3968                  if (info->shared || info->pie)
3969                    (*_bfd_error_handler)
3970                      (_("%B(%A+0x%lx): reloc against `%s': %s"),
3971                       input_bfd, input_section, (long)rel->r_offset, name,
3972                       _("relocation references a different segment"));
3973                  else
3974                    info->callbacks->warning
3975                      (info,
3976                       _("relocation references a different segment"),
3977                       name, input_bfd, input_section, rel->r_offset);
3978                }
3979              if (!silence_segment_error && (info->shared || info->pie))
3980                return FALSE;
3981              elf_elfheader (output_bfd)->e_flags |= EF_FRV_PIC;
3982            }
3983    
3984          switch (r_type)
3985            {
3986            case R_FRV_GOTOFFHI:
3987            case R_FRV_TLSMOFFHI:
3988              /* We need the addend to be applied before we shift the
3989                 value right.  */
3990              relocation += rel->r_addend;
3991              /* Fall through.  */
3992            case R_FRV_GOTHI:
3993            case R_FRV_FUNCDESC_GOTHI:
3994            case R_FRV_FUNCDESC_GOTOFFHI:
3995            case R_FRV_GOTTLSOFFHI:
3996            case R_FRV_GOTTLSDESCHI:
3997              relocation >>= 16;
3998              /* Fall through.  */
3999    
4000            case R_FRV_GOTLO:
4001            case R_FRV_FUNCDESC_GOTLO:
4002            case R_FRV_GOTOFFLO:
4003            case R_FRV_FUNCDESC_GOTOFFLO:
4004            case R_FRV_GOTTLSOFFLO:
4005            case R_FRV_GOTTLSDESCLO:
4006            case R_FRV_TLSMOFFLO:
4007              relocation &= 0xffff;
4008              break;
4009    
4010            default:
4011              break;
4012            }
4013    
4014          switch (r_type)
4015            {
4016            case R_FRV_LABEL24:
4017              if (! IS_FDPIC (output_bfd) || ! picrel->plt)
4018                break;
4019              /* Fall through.  */
4020    
4021              /* When referencing a GOT entry, a function descriptor or a
4022                 PLT, we don't want the addend to apply to the reference,
4023                 but rather to the referenced symbol.  The actual entry
4024                 will have already been created taking the addend into
4025                 account, so cancel it out here.  */
4026            case R_FRV_GOT12:
4027            case R_FRV_GOTHI:
4028            case R_FRV_GOTLO:
4029            case R_FRV_FUNCDESC_GOT12:
4030            case R_FRV_FUNCDESC_GOTHI:
4031            case R_FRV_FUNCDESC_GOTLO:
4032            case R_FRV_FUNCDESC_GOTOFF12:
4033            case R_FRV_FUNCDESC_GOTOFFHI:
4034            case R_FRV_FUNCDESC_GOTOFFLO:
4035            case R_FRV_GETTLSOFF:
4036            case R_FRV_GOTTLSDESC12:
4037            case R_FRV_GOTTLSDESCHI:
4038            case R_FRV_GOTTLSDESCLO:
4039            case R_FRV_GOTTLSOFF12:
4040            case R_FRV_GOTTLSOFFHI:
4041            case R_FRV_GOTTLSOFFLO:
4042              /* Note that we only want GOTOFFHI, not GOTOFFLO or GOTOFF12
4043                 here, since we do want to apply the addend to the others.
4044                 Note that we've applied the addend to GOTOFFHI before we
4045                 shifted it right.  */
4046            case R_FRV_GOTOFFHI:
4047            case R_FRV_TLSMOFFHI:
4048              relocation -= rel->r_addend;
4049              break;
4050    
4051            default:
4052              break;
4053            }
4054    
4055       if (r_type == R_FRV_HI16)       if (r_type == R_FRV_HI16)
4056         r = elf32_frv_relocate_hi16 (input_bfd, rel, contents, relocation);         r = elf32_frv_relocate_hi16 (input_bfd, rel, contents, relocation);
4057    
4058       else if (r_type == R_FRV_LO16)       else if (r_type == R_FRV_LO16)
4059         r = elf32_frv_relocate_lo16 (input_bfd, rel, contents, relocation);         r = elf32_frv_relocate_lo16 (input_bfd, rel, contents, relocation);
4060    
4061       else if (r_type == R_FRV_LABEL24)       else if (r_type == R_FRV_LABEL24 || r_type == R_FRV_GETTLSOFF)
4062         r = elf32_frv_relocate_label24 (input_bfd, input_section, rel, contents, relocation);         r = elf32_frv_relocate_label24 (input_bfd, input_section, rel,
4063                                           contents, relocation);
4064    
4065       else if (r_type == R_FRV_GPREL12)       else if (r_type == R_FRV_GPREL12)
4066         r = elf32_frv_relocate_gprel12 (info, input_bfd, input_section, rel, contents, relocation);         r = elf32_frv_relocate_gprel12 (info, input_bfd, input_section, rel,
4067                                           contents, relocation);
4068    
4069       else if (r_type == R_FRV_GPRELU12)       else if (r_type == R_FRV_GPRELU12)
4070         r = elf32_frv_relocate_gprelu12 (info, input_bfd, input_section, rel, contents, relocation);         r = elf32_frv_relocate_gprelu12 (info, input_bfd, input_section, rel,
4071                                            contents, relocation);
4072    
4073       else if (r_type == R_FRV_GPRELLO)       else if (r_type == R_FRV_GPRELLO)
4074         r = elf32_frv_relocate_gprello (info, input_bfd, input_section, rel, contents, relocation);         r = elf32_frv_relocate_gprello (info, input_bfd, input_section, rel,
4075                                           contents, relocation);
4076    
4077       else if (r_type == R_FRV_GPRELHI)       else if (r_type == R_FRV_GPRELHI)
4078         r = elf32_frv_relocate_gprelhi (info, input_bfd, input_section, rel, contents, relocation);         r = elf32_frv_relocate_gprelhi (info, input_bfd, input_section, rel,
4079                                           contents, relocation);
4080    
4081         else if (r_type == R_FRV_TLSOFF
4082                  || r_type == R_FRV_TLSDESC_VALUE)
4083           r = bfd_reloc_notsupported;
4084    
4085       else       else
4086         r = frv_final_link_relocate (howto, input_bfd, input_section, contents, rel, relocation);         r = frv_final_link_relocate (howto, input_bfd, input_section, contents,
4087                                        rel, relocation);
4088    
4089        if (r != bfd_reloc_ok)        if (r != bfd_reloc_ok)
4090          {          {
# Line 796  elf32_frv_relocate_section (output_bfd, Line 4094  elf32_frv_relocate_section (output_bfd,
4094              {              {
4095              case bfd_reloc_overflow:              case bfd_reloc_overflow:
4096                r = info->callbacks->reloc_overflow                r = info->callbacks->reloc_overflow
4097                  (info, name, howto->name, (bfd_vma) 0,                  (info, (h ? &h->root : NULL), name, howto->name,
4098                   input_bfd, input_section, rel->r_offset);                   (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
4099                break;                break;
4100                  
4101              case bfd_reloc_undefined:              case bfd_reloc_undefined:
4102                r = info->callbacks->undefined_symbol                r = info->callbacks->undefined_symbol
4103                  (info, name, input_bfd, input_section, rel->r_offset, true);                  (info, name, input_bfd, input_section, rel->r_offset, TRUE);
4104                break;                break;
4105                  
4106              case bfd_reloc_outofrange:              case bfd_reloc_outofrange:
4107                msg = _("internal error: out of range error");                msg = _("internal error: out of range error");
4108                break;                break;
# Line 823  elf32_frv_relocate_section (output_bfd, Line 4121  elf32_frv_relocate_section (output_bfd,
4121              }              }
4122    
4123            if (msg)            if (msg)
4124              r = info->callbacks->warning              {
4125                (info, msg, name, input_bfd, input_section, rel->r_offset);                (*_bfd_error_handler)
4126                    (_("%B(%A+0x%lx): reloc against `%s': %s"),
4127                     input_bfd, input_section, (long)rel->r_offset, name, msg);
4128                  return FALSE;
4129                }
4130    
4131            if (! r)            if (! r)
4132              return false;              return FALSE;
4133          }          }
4134      }      }
4135    
4136    return true;    return TRUE;
4137  }  }
4138    
4139  /* Return the section that should be marked against GC for a given  /* Return the section that should be marked against GC for a given
# Line 839  elf32_frv_relocate_section (output_bfd, Line 4141  elf32_frv_relocate_section (output_bfd,
4141    
4142  static asection *  static asection *
4143  elf32_frv_gc_mark_hook (sec, info, rel, h, sym)  elf32_frv_gc_mark_hook (sec, info, rel, h, sym)
4144       asection *                   sec;       asection *sec;
4145       struct bfd_link_info *       info ATTRIBUTE_UNUSED;       struct bfd_link_info *info ATTRIBUTE_UNUSED;
4146       Elf_Internal_Rela *          rel;       Elf_Internal_Rela *rel;
4147       struct elf_link_hash_entry * h;       struct elf_link_hash_entry *h;
4148       Elf_Internal_Sym *           sym;       Elf_Internal_Sym *sym;
4149  {  {
4150    if (h != NULL)    if (h != NULL)
4151      {      {
# Line 876  elf32_frv_gc_mark_hook (sec, info, rel, Line 4178  elf32_frv_gc_mark_hook (sec, info, rel,
4178    
4179  /* Update the got entry reference counts for the section being removed.  */  /* Update the got entry reference counts for the section being removed.  */
4180    
4181  static boolean  static bfd_boolean
4182  elf32_frv_gc_sweep_hook (abfd, info, sec, relocs)  elf32_frv_gc_sweep_hook (abfd, info, sec, relocs)
4183       bfd *                     abfd ATTRIBUTE_UNUSED;       bfd *abfd ATTRIBUTE_UNUSED;
4184       struct bfd_link_info *    info ATTRIBUTE_UNUSED;       struct bfd_link_info *info ATTRIBUTE_UNUSED;
4185       asection *                sec ATTRIBUTE_UNUSED;       asection *sec ATTRIBUTE_UNUSED;
4186       const Elf_Internal_Rela * relocs ATTRIBUTE_UNUSED;       const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED;
4187  {  {
4188    return true;    return TRUE;
4189  }  }
4190    
4191    
4192  /* Hook called by the linker routine which adds symbols from an object  /* Hook called by the linker routine which adds symbols from an object
4193     file.  We use it to put .comm items in .scomm, and not .comm.  */     file.  We use it to put .comm items in .scomm, and not .comm.  */
4194    
4195  static boolean  static bfd_boolean
4196  elf32_frv_add_symbol_hook (abfd, info, sym, namep, flagsp, secp, valp)  elf32_frv_add_symbol_hook (abfd, info, sym, namep, flagsp, secp, valp)
4197       bfd *abfd;       bfd *abfd;
4198       struct bfd_link_info *info;       struct bfd_link_info *info;
4199       const Elf_Internal_Sym *sym;       Elf_Internal_Sym *sym;
4200       const char **namep ATTRIBUTE_UNUSED;       const char **namep ATTRIBUTE_UNUSED;
4201       flagword *flagsp ATTRIBUTE_UNUSED;       flagword *flagsp ATTRIBUTE_UNUSED;
4202       asection **secp;       asection **secp;
4203       bfd_vma *valp;       bfd_vma *valp;
4204  {  {
4205    if (sym->st_shndx == SHN_COMMON    if (sym->st_shndx == SHN_COMMON
4206        && !info->relocateable        && !info->relocatable
4207        && (int)sym->st_size <= (int)bfd_get_gp_size (abfd))        && (int)sym->st_size <= (int)bfd_get_gp_size (abfd))
4208      {      {
4209        /* Common symbols less than or equal to -G nn bytes are        /* Common symbols less than or equal to -G nn bytes are
# Line 916  elf32_frv_add_symbol_hook (abfd, info, s Line 4218  elf32_frv_add_symbol_hook (abfd, info, s
4218                || !bfd_set_section_flags (abfd, scomm, (SEC_ALLOC                || !bfd_set_section_flags (abfd, scomm, (SEC_ALLOC
4219                                                         | SEC_IS_COMMON                                                         | SEC_IS_COMMON
4220                                                         | SEC_LINKER_CREATED)))                                                         | SEC_LINKER_CREATED)))
4221              return false;              return FALSE;
4222          }          }
4223    
4224        *secp = scomm;        *secp = scomm;
4225        *valp = sym->st_size;        *valp = sym->st_size;
4226      }      }
4227    
4228    return true;    return TRUE;
4229    }
4230    
4231    /* We need dynamic symbols for every section, since segments can
4232       relocate independently.  */
4233    static bfd_boolean
4234    _frvfdpic_link_omit_section_dynsym (bfd *output_bfd ATTRIBUTE_UNUSED,
4235                                        struct bfd_link_info *info
4236                                        ATTRIBUTE_UNUSED,
4237                                        asection *p ATTRIBUTE_UNUSED)
4238    {
4239      switch (elf_section_data (p)->this_hdr.sh_type)
4240        {
4241        case SHT_PROGBITS:
4242        case SHT_NOBITS:
4243          /* If sh_type is yet undecided, assume it could be
4244             SHT_PROGBITS/SHT_NOBITS.  */
4245        case SHT_NULL:
4246          return FALSE;
4247    
4248          /* There shouldn't be section relative relocations
4249             against any other section.  */
4250        default:
4251          return TRUE;
4252        }
4253    }
4254    
4255    /* Create  a .got section, as well as its additional info field.  This
4256       is almost entirely copied from
4257       elflink.c:_bfd_elf_create_got_section().  */
4258    
4259    static bfd_boolean
4260    _frv_create_got_section (bfd *abfd, struct bfd_link_info *info)
4261    {
4262      flagword flags, pltflags;
4263      asection *s;
4264      struct elf_link_hash_entry *h;
4265      struct bfd_link_hash_entry *bh;
4266      const struct elf_backend_data *bed = get_elf_backend_data (abfd);
4267      int ptralign;
4268      int offset;
4269    
4270      /* This function may be called more than once.  */
4271      s = bfd_get_section_by_name (abfd, ".got");
4272      if (s != NULL && (s->flags & SEC_LINKER_CREATED) != 0)
4273        return TRUE;
4274    
4275      /* Machine specific: although pointers are 32-bits wide, we want the
4276         GOT to be aligned to a 64-bit boundary, such that function
4277         descriptors in it can be accessed with 64-bit loads and
4278         stores.  */
4279      ptralign = 3;
4280    
4281      flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4282               | SEC_LINKER_CREATED);
4283      pltflags = flags;
4284    
4285      s = bfd_make_section (abfd, ".got");
4286      if (s == NULL
4287          || !bfd_set_section_flags (abfd, s, flags)
4288          || !bfd_set_section_alignment (abfd, s, ptralign))
4289        return FALSE;
4290    
4291      if (bed->want_got_plt)
4292        {
4293          s = bfd_make_section (abfd, ".got.plt");
4294          if (s == NULL
4295              || !bfd_set_section_flags (abfd, s, flags)
4296              || !bfd_set_section_alignment (abfd, s, ptralign))
4297            return FALSE;
4298        }
4299    
4300      if (bed->want_got_sym)
4301        {
4302          /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the .got
4303             (or .got.plt) section.  We don't do this in the linker script
4304             because we don't want to define the symbol if we are not creating
4305             a global offset table.  */
4306          bh = NULL;
4307          if (!(_bfd_generic_link_add_one_symbol
4308                (info, abfd, "_GLOBAL_OFFSET_TABLE_", BSF_GLOBAL, s,
4309                 bed->got_symbol_offset, (const char *) NULL, FALSE,
4310                 bed->collect, &bh)))
4311            return FALSE;
4312          h = (struct elf_link_hash_entry *) bh;
4313          h->def_regular = 1;
4314          h->type = STT_OBJECT;
4315          /* h->other = STV_HIDDEN; */ /* Should we?  */
4316    
4317          /* Machine-specific: we want the symbol for executables as
4318             well.  */
4319          if (! bfd_elf_link_record_dynamic_symbol (info, h))
4320            return FALSE;
4321    
4322          elf_hash_table (info)->hgot = h;
4323        }
4324    
4325      /* The first bit of the global offset table is the header.  */
4326      s->size += bed->got_header_size + bed->got_symbol_offset;
4327    
4328      /* This is the machine-specific part.  Create and initialize section
4329         data for the got.  */
4330      if (IS_FDPIC (abfd))
4331        {
4332          frvfdpic_got_section (info) = s;
4333          frvfdpic_relocs_info (info) = htab_try_create (1,
4334                                                         frvfdpic_relocs_info_hash,
4335                                                         frvfdpic_relocs_info_eq,
4336                                                         (htab_del) NULL);
4337          if (! frvfdpic_relocs_info (info))
4338            return FALSE;
4339    
4340          s = bfd_make_section (abfd, ".rel.got");
4341          if (s == NULL
4342              || ! bfd_set_section_flags (abfd, s, (flags | SEC_READONLY))
4343              || ! bfd_set_section_alignment (abfd, s, 2))
4344            return FALSE;
4345    
4346          frvfdpic_gotrel_section (info) = s;
4347    
4348          /* Machine-specific.  */
4349          s = bfd_make_section (abfd, ".rofixup");
4350          if (s == NULL
4351              || ! bfd_set_section_flags (abfd, s, (flags | SEC_READONLY))
4352              || ! bfd_set_section_alignment (abfd, s, 2))
4353            return FALSE;
4354    
4355          frvfdpic_gotfixup_section (info) = s;
4356          offset = -2048;
4357          flags = BSF_GLOBAL;
4358        }
4359      else
4360        {
4361          offset = 2048;
4362          flags = BSF_GLOBAL | BSF_WEAK;
4363        }
4364    
4365      /* Define _gp in .rofixup, for FDPIC, or .got otherwise.  If it
4366         turns out that we're linking with a different linker script, the
4367         linker script will override it.  */
4368      bh = NULL;
4369      if (!(_bfd_generic_link_add_one_symbol
4370            (info, abfd, "_gp", flags, s, offset, (const char *) NULL, FALSE,
4371             bed->collect, &bh)))
4372        return FALSE;
4373      h = (struct elf_link_hash_entry *) bh;
4374      h->def_regular = 1;
4375      h->type = STT_OBJECT;
4376      /* h->other = STV_HIDDEN; */ /* Should we?  */
4377    
4378      /* Machine-specific: we want the symbol for executables as well.  */
4379      if (IS_FDPIC (abfd) && ! bfd_elf_link_record_dynamic_symbol (info, h))
4380        return FALSE;
4381    
4382      if (!IS_FDPIC (abfd))
4383        return TRUE;
4384    
4385      /* FDPIC supports Thread Local Storage, and this may require a
4386         procedure linkage table for TLS PLT entries.  */
4387    
4388      /* This is mostly copied from
4389         elflink.c:_bfd_elf_create_dynamic_sections().  */
4390    
4391      flags = pltflags;
4392      pltflags |= SEC_CODE;
4393      if (bed->plt_not_loaded)
4394        pltflags &= ~ (SEC_CODE | SEC_LOAD | SEC_HAS_CONTENTS);
4395      if (bed->plt_readonly)
4396        pltflags |= SEC_READONLY;
4397    
4398      s = bfd_make_section (abfd, ".plt");
4399      if (s == NULL
4400          || ! bfd_set_section_flags (abfd, s, pltflags)
4401          || ! bfd_set_section_alignment (abfd, s, bed->plt_alignment))
4402        return FALSE;
4403      /* FRV-specific: remember it.  */
4404      frvfdpic_plt_section (info) = s;
4405    
4406      if (bed->want_plt_sym)
4407        {
4408          /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
4409             .plt section.  */
4410          struct elf_link_hash_entry *h;
4411          struct bfd_link_hash_entry *bh = NULL;
4412    
4413          if (! (_bfd_generic_link_add_one_symbol
4414                 (info, abfd, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL, s, 0, NULL,
4415                  FALSE, get_elf_backend_data (abfd)->collect, &bh)))
4416            return FALSE;
4417          h = (struct elf_link_hash_entry *) bh;
4418          h->def_regular = 1;
4419          h->type = STT_OBJECT;
4420          /* h->other = STV_HIDDEN; */ /* Should we?  */
4421    
4422          if (! info->executable
4423              && ! bfd_elf_link_record_dynamic_symbol (info, h))
4424            return FALSE;
4425        }
4426    
4427      /* FRV-specific: we want rel relocations for the plt.  */
4428      s = bfd_make_section (abfd, ".rel.plt");
4429      if (s == NULL
4430          || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
4431          || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
4432        return FALSE;
4433      /* FRV-specific: remember it.  */
4434      frvfdpic_pltrel_section (info) = s;
4435    
4436      return TRUE;
4437    }
4438    
4439    /* Make sure the got and plt sections exist, and that our pointers in
4440       the link hash table point to them.  */
4441    
4442    static bfd_boolean
4443    elf32_frvfdpic_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
4444    {
4445      /* This is mostly copied from
4446         elflink.c:_bfd_elf_create_dynamic_sections().  */
4447      flagword flags;
4448      asection *s;
4449      const struct elf_backend_data *bed = get_elf_backend_data (abfd);
4450    
4451      flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4452               | SEC_LINKER_CREATED);
4453    
4454      /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
4455         .rel[a].bss sections.  */
4456    
4457      /* FRV-specific: we want to create the GOT and the PLT in the FRV
4458         way.  */
4459      if (! _frv_create_got_section (abfd, info))
4460        return FALSE;
4461    
4462      /* FRV-specific: make sure we created everything we wanted.  */
4463      BFD_ASSERT (frvfdpic_got_section (info) && frvfdpic_gotrel_section (info)
4464                  && frvfdpic_gotfixup_section (info)
4465                  && frvfdpic_plt_section (info)
4466                  && frvfdpic_pltrel_section (info));
4467    
4468      if (bed->want_dynbss)
4469        {
4470          /* The .dynbss section is a place to put symbols which are defined
4471             by dynamic objects, are referenced by regular objects, and are
4472             not functions.  We must allocate space for them in the process
4473             image and use a R_*_COPY reloc to tell the dynamic linker to
4474             initialize them at run time.  The linker script puts the .dynbss
4475             section into the .bss section of the final image.  */
4476          s = bfd_make_section (abfd, ".dynbss");
4477          if (s == NULL
4478              || ! bfd_set_section_flags (abfd, s, SEC_ALLOC | SEC_LINKER_CREATED))
4479            return FALSE;
4480    
4481          /* The .rel[a].bss section holds copy relocs.  This section is not
4482         normally needed.  We need to create it here, though, so that the
4483         linker will map it to an output section.  We can't just create it
4484         only if we need it, because we will not know whether we need it
4485         until we have seen all the input files, and the first time the
4486         main linker code calls BFD after examining all the input files
4487         (size_dynamic_sections) the input sections have already been
4488         mapped to the output sections.  If the section turns out not to
4489         be needed, we can discard it later.  We will never need this
4490         section when generating a shared object, since they do not use
4491         copy relocs.  */
4492          if (! info->shared)
4493            {
4494              s = bfd_make_section (abfd,
4495                                    (bed->default_use_rela_p
4496                                     ? ".rela.bss" : ".rel.bss"));
4497              if (s == NULL
4498                  || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
4499                  || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
4500                return FALSE;
4501            }
4502        }
4503    
4504      return TRUE;
4505  }  }
4506    
4507    /* Compute the total GOT and PLT size required by each symbol in each
4508       range.  Symbols may require up to 4 words in the GOT: an entry
4509       pointing to the symbol, an entry pointing to its function
4510       descriptor, and a private function descriptors taking two
4511       words.  */
4512    
4513    static void
4514    _frvfdpic_count_nontls_entries (struct frvfdpic_relocs_info *entry,
4515                                    struct _frvfdpic_dynamic_got_info *dinfo)
4516    {
4517      /* Allocate space for a GOT entry pointing to the symbol.  */
4518      if (entry->got12)
4519        dinfo->got12 += 4;
4520      else if (entry->gotlos)
4521        dinfo->gotlos += 4;
4522      else if (entry->gothilo)
4523        dinfo->gothilo += 4;
4524      else
4525        entry->relocs32--;
4526      entry->relocs32++;
4527    
4528      /* Allocate space for a GOT entry pointing to the function
4529         descriptor.  */
4530      if (entry->fdgot12)
4531        dinfo->got12 += 4;
4532      else if (entry->fdgotlos)
4533        dinfo->gotlos += 4;
4534      else if (entry->fdgothilo)
4535        dinfo->gothilo += 4;
4536      else
4537        entry->relocsfd--;
4538      entry->relocsfd++;
4539    
4540      /* Decide whether we need a PLT entry, a function descriptor in the
4541         GOT, and a lazy PLT entry for this symbol.  */
4542      entry->plt = entry->call
4543        && entry->symndx == -1 && ! FRVFDPIC_SYM_LOCAL (dinfo->info, entry->d.h)
4544        && elf_hash_table (dinfo->info)->dynamic_sections_created;
4545      entry->privfd = entry->plt
4546        || entry->fdgoff12 || entry->fdgofflos || entry->fdgoffhilo
4547        || ((entry->fd || entry->fdgot12 || entry->fdgotlos || entry->fdgothilo)
4548            && (entry->symndx != -1
4549                || FRVFDPIC_FUNCDESC_LOCAL (dinfo->info, entry->d.h)));
4550      entry->lazyplt = entry->privfd
4551        && entry->symndx == -1 && ! FRVFDPIC_SYM_LOCAL (dinfo->info, entry->d.h)
4552        && ! (dinfo->info->flags & DF_BIND_NOW)
4553        && elf_hash_table (dinfo->info)->dynamic_sections_created;
4554    
4555      /* Allocate space for a function descriptor.  */
4556      if (entry->fdgoff12)
4557        dinfo->fd12 += 8;
4558      else if (entry->fdgofflos)
4559        dinfo->fdlos += 8;
4560      else if (entry->privfd && entry->plt)
4561        dinfo->fdplt += 8;
4562      else if (entry->privfd)
4563        dinfo->fdhilo += 8;
4564      else
4565        entry->relocsfdv--;
4566      entry->relocsfdv++;
4567    
4568      if (entry->lazyplt)
4569        dinfo->lzplt += 8;
4570    }
4571    
4572    /* Compute the total GOT size required by each TLS symbol in each
4573       range.  Symbols may require up to 5 words in the GOT: an entry
4574       holding the TLS offset for the symbol, and an entry with a full TLS
4575       descriptor taking 4 words.  */
4576    
4577    static void
4578    _frvfdpic_count_tls_entries (struct frvfdpic_relocs_info *entry,
4579                                 struct _frvfdpic_dynamic_got_info *dinfo,
4580                                 bfd_boolean subtract)
4581    {
4582      const int l = subtract ? -1 : 1;
4583      
4584      /* Allocate space for a GOT entry with the TLS offset of the
4585         symbol.  */
4586      if (entry->tlsoff12)
4587        dinfo->got12 += 4 * l;
4588      else if (entry->tlsofflos)
4589        dinfo->gotlos += 4 * l;
4590      else if (entry->tlsoffhilo)
4591        dinfo->gothilo += 4 * l;
4592      else
4593        entry->relocstlsoff -= l;
4594      entry->relocstlsoff += l;
4595    
4596      /* If there's any TLSOFF relocation, mark the output file as not
4597         suitable for dlopening.  This mark will remain even if we relax
4598         all such relocations, but this is not a problem, since we'll only
4599         do so for executables, and we definitely don't want anyone
4600         dlopening executables.  */
4601      if (entry->relocstlsoff)
4602        dinfo->info->flags |= DF_STATIC_TLS;
4603    
4604      /* Allocate space for a TLS descriptor.  */
4605      if (entry->tlsdesc12)
4606        dinfo->tlsd12 += 8 * l;
4607      else if (entry->tlsdesclos)
4608        dinfo->tlsdlos += 8 * l;
4609      else if (entry->tlsplt)
4610        dinfo->tlsdplt += 8 * l;
4611      else if (entry->tlsdeschilo)
4612        dinfo->tlsdhilo += 8 * l;
4613      else
4614        entry->relocstlsd -= l;
4615      entry->relocstlsd += l;
4616    }
4617    
4618    /* Compute the number of dynamic relocations and fixups that a symbol
4619       requires, and add (or subtract) from the grand and per-symbol
4620       totals.  */
4621    
4622    static void
4623    _frvfdpic_count_relocs_fixups (struct frvfdpic_relocs_info *entry,
4624                                   struct _frvfdpic_dynamic_got_info *dinfo,
4625                                   bfd_boolean subtract)
4626    {
4627      bfd_vma relocs = 0, fixups = 0, tlsrets = 0;
4628    
4629      if (!dinfo->info->executable || dinfo->info->pie)
4630        {
4631          relocs = entry->relocs32 + entry->relocsfd + entry->relocsfdv
4632            + entry->relocstlsd;
4633    
4634          /* In the executable, TLS relocations to symbols that bind
4635             locally (including those that resolve to global TLS offsets)
4636             are resolved immediately, without any need for fixups or
4637             dynamic relocations.  In shared libraries, however, we must
4638             emit dynamic relocations even for local symbols, because we
4639             don't know the module id the library is going to get at
4640             run-time, nor its TLS base offset.  */
4641          if (!dinfo->info->executable
4642              || (entry->symndx == -1
4643                  && ! FRVFDPIC_SYM_LOCAL (dinfo->info, entry->d.h)))
4644            relocs += entry->relocstlsoff;
4645        }
4646      else
4647        {
4648          if (entry->symndx != -1 || FRVFDPIC_SYM_LOCAL (dinfo->info, entry->d.h))
4649            {
4650              if (entry->symndx != -1
4651                  || entry->d.h->root.type != bfd_link_hash_undefweak)
4652                fixups += entry->relocs32 + 2 * entry->relocsfdv;
4653              fixups += entry->relocstlsd;
4654              tlsrets += entry->relocstlsd;
4655            }
4656          else
4657            {
4658              relocs += entry->relocs32 + entry->relocsfdv
4659                + entry->relocstlsoff + entry->relocstlsd;
4660            }
4661    
4662          if (entry->symndx != -1
4663              || FRVFDPIC_FUNCDESC_LOCAL (dinfo->info, entry->d.h))
4664            {
4665              if (entry->symndx != -1
4666                  || entry->d.h->root.type != bfd_link_hash_undefweak)
4667                fixups += entry->relocsfd;
4668            }
4669          else
4670            relocs += entry->relocsfd;
4671        }
4672    
4673      if (subtract)
4674        {
4675          relocs = - relocs;
4676          fixups = - fixups;
4677          tlsrets = - tlsrets;
4678        }
4679    
4680      entry->dynrelocs += relocs;
4681      entry->fixups += fixups;
4682      dinfo->relocs += relocs;
4683      dinfo->fixups += fixups;
4684      dinfo->tls_ret_refs += tlsrets;
4685    }
4686    
4687    /* Look for opportunities to relax TLS relocations.  We can assume
4688       we're linking the main executable or a static-tls library, since
4689       otherwise we wouldn't have got here.  When relaxing, we have to
4690       first undo any previous accounting of TLS uses of fixups, dynamic
4691       relocations, GOT and PLT entries.  */
4692    
4693    static void
4694    _frvfdpic_relax_tls_entries (struct frvfdpic_relocs_info *entry,
4695                                 struct _frvfdpic_dynamic_got_info *dinfo,
4696                                 bfd_boolean relaxing)
4697    {
4698      bfd_boolean changed = ! relaxing;
4699    
4700      BFD_ASSERT (dinfo->info->executable
4701                  || (dinfo->info->flags & DF_STATIC_TLS));
4702    
4703      if (entry->tlsdesc12 || entry->tlsdesclos || entry->tlsdeschilo)
4704        {
4705          if (! changed)
4706            {
4707              _frvfdpic_count_relocs_fixups (entry, dinfo, TRUE);
4708              _frvfdpic_count_tls_entries (entry, dinfo, TRUE);
4709              changed = TRUE;
4710            }
4711    
4712          /* When linking an executable, we can always decay GOTTLSDESC to
4713             TLSMOFF, if the symbol is local, or GOTTLSOFF, otherwise.
4714             When linking a static-tls shared library, using TLSMOFF is
4715             not an option, but we can still use GOTTLSOFF.  When decaying
4716             to GOTTLSOFF, we must keep the GOT entry in range.  We know
4717             it has to fit because we'll be trading the 4 words of hte TLS
4718             descriptor for a single word in the same range.  */
4719          if (! dinfo->info->executable
4720              || (entry->symndx == -1
4721                  && ! FRVFDPIC_SYM_LOCAL (dinfo->info, entry->d.h)))
4722            {
4723              entry->tlsoff12 |= entry->tlsdesc12;
4724              entry->tlsofflos |= entry->tlsdesclos;
4725              entry->tlsoffhilo |= entry->tlsdeschilo;
4726            }
4727    
4728          entry->tlsdesc12 = entry->tlsdesclos = entry->tlsdeschilo = 0;
4729        }
4730    
4731      /* We can only decay TLSOFFs or call #gettlsoff to TLSMOFF in the
4732         main executable.  We have to check whether the symbol's TLSOFF is
4733         in range for a setlos.  For symbols with a hash entry, we can
4734         determine exactly what to do; for others locals, we don't have
4735         addresses handy, so we use the size of the TLS section as an
4736         approximation.  If we get it wrong, we'll retain a GOT entry
4737         holding the TLS offset (without dynamic relocations or fixups),
4738         but we'll still optimize away the loads from it.  Since TLS sizes
4739         are generally very small, it's probably not worth attempting to
4740         do better than this.  */
4741      if ((entry->tlsplt
4742           || entry->tlsoff12 || entry->tlsofflos || entry->tlsoffhilo)
4743          && dinfo->info->executable && relaxing
4744          && ((entry->symndx == -1
4745               && FRVFDPIC_SYM_LOCAL (dinfo->info, entry->d.h)
4746               /* The above may hold for an undefweak TLS symbol, so make
4747                  sure we don't have this case before accessing def.value
4748                  and def.section.  */
4749               && (entry->d.h->root.type == bfd_link_hash_undefweak
4750                   || (bfd_vma)(entry->d.h->root.u.def.value
4751                                + (entry->d.h->root.u.def.section
4752                                   ->output_section->vma)
4753                                + entry->d.h->root.u.def.section->output_offset
4754                                + entry->addend
4755                                - tls_biased_base (dinfo->info)
4756                                + 32768) < (bfd_vma)65536))
4757              || (entry->symndx != -1
4758                  && (elf_hash_table (dinfo->info)->tls_sec->size
4759                      + abs (entry->addend) < 32768 + FRVFDPIC_TLS_BIAS))))
4760        {
4761          if (! changed)
4762            {
4763              _frvfdpic_count_relocs_fixups (entry, dinfo, TRUE);
4764              _frvfdpic_count_tls_entries (entry, dinfo, TRUE);
4765              changed = TRUE;
4766            }
4767          
4768          entry->tlsplt =
4769            entry->tlsoff12 = entry->tlsofflos = entry->tlsoffhilo = 0;
4770        }
4771    
4772      /* We can decay `call #gettlsoff' to a ldi #tlsoff if we already
4773         have a #gottlsoff12 relocation for this entry, or if we can fit
4774         one more in the 12-bit (and 16-bit) ranges.  */
4775      if (entry->tlsplt
4776          && (entry->tlsoff12
4777              || (relaxing
4778                  && dinfo->got12 + dinfo->fd12 + dinfo->tlsd12 <= 4096 - 12 - 4
4779                  && (dinfo->got12 + dinfo->fd12 + dinfo->tlsd12
4780                      + dinfo->gotlos + dinfo->fdlos + dinfo->tlsdlos
4781                      <= 65536 - 12 - 4))))
4782        {
4783          if (! changed)
4784            {
4785              _frvfdpic_count_relocs_fixups (entry, dinfo, TRUE);
4786              _frvfdpic_count_tls_entries (entry, dinfo, TRUE);
4787              changed = TRUE;
4788            }
4789    
4790          entry->tlsoff12 = 1;
4791          entry->tlsplt = 0;
4792        }
4793    
4794      if (changed)
4795        {
4796          _frvfdpic_count_tls_entries (entry, dinfo, FALSE);
4797          _frvfdpic_count_relocs_fixups (entry, dinfo, FALSE);
4798        }
4799    
4800      return;
4801    }
4802    
4803    /* Compute the total GOT and PLT size required by each symbol in each range. *
4804       Symbols may require up to 4 words in the GOT: an entry pointing to
4805       the symbol, an entry pointing to its function descriptor, and a
4806       private function descriptors taking two words.  */
4807    
4808    static int
4809    _frvfdpic_count_got_plt_entries (void **entryp, void *dinfo_)
4810    {
4811      struct frvfdpic_relocs_info *entry = *entryp;
4812      struct _frvfdpic_dynamic_got_info *dinfo = dinfo_;
4813    
4814      _frvfdpic_count_nontls_entries (entry, dinfo);
4815    
4816      if (dinfo->info->executable || (dinfo->info->flags & DF_STATIC_TLS))
4817        _frvfdpic_relax_tls_entries (entry, dinfo, FALSE);
4818      else
4819        {
4820          _frvfdpic_count_tls_entries (entry, dinfo, FALSE);
4821          _frvfdpic_count_relocs_fixups (entry, dinfo, FALSE);
4822        }
4823    
4824      return 1;
4825    }
4826    
4827    /* Determine the positive and negative ranges to be used by each
4828       offset range in the GOT.  FDCUR and CUR, that must be aligned to a
4829       double-word boundary, are the minimum (negative) and maximum
4830       (positive) GOT offsets already used by previous ranges, except for
4831       an ODD entry that may have been left behind.  GOT and FD indicate
4832       the size of GOT entries and function descriptors that must be
4833       placed within the range from -WRAP to WRAP.  If there's room left,
4834       up to FDPLT bytes should be reserved for additional function
4835       descriptors.  */
4836    
4837    inline static bfd_signed_vma
4838    _frvfdpic_compute_got_alloc_data (struct _frvfdpic_dynamic_got_alloc_data *gad,
4839                                      bfd_signed_vma fdcur,
4840                                      bfd_signed_vma odd,
4841                                      bfd_signed_vma cur,
4842                                      bfd_vma got,
4843                                      bfd_vma fd,
4844                                      bfd_vma fdplt,
4845                                      bfd_vma tlsd,
4846                                      bfd_vma tlsdplt,
4847                                      bfd_vma wrap)
4848    {
4849      bfd_signed_vma wrapmin = -wrap;
4850      const bfd_vma tdescsz = 8;
4851    
4852      /* Start at the given initial points.  */
4853      gad->fdcur = fdcur;
4854      gad->cur = cur;
4855    
4856      /* If we had an incoming odd word and we have any got entries that
4857         are going to use it, consume it, otherwise leave gad->odd at
4858         zero.  We might force gad->odd to zero and return the incoming
4859         odd such that it is used by the next range, but then GOT entries
4860         might appear to be out of order and we wouldn't be able to
4861         shorten the GOT by one word if it turns out to end with an
4862         unpaired GOT entry.  */
4863      if (odd && got)
4864        {
4865          gad->odd = odd;
4866          got -= 4;
4867          odd = 0;
4868        }
4869      else
4870        gad->odd = 0;
4871    
4872      /* If we're left with an unpaired GOT entry, compute its location
4873         such that we can return it.  Otherwise, if got doesn't require an
4874         odd number of words here, either odd was already zero in the
4875         block above, or it was set to zero because got was non-zero, or
4876         got was already zero.  In the latter case, we want the value of
4877         odd to carry over to the return statement, so we don't want to
4878         reset odd unless the condition below is true.  */
4879      if (got & 4)
4880        {
4881          odd = cur + got;
4882          got += 4;
4883        }
4884    
4885      /* Compute the tentative boundaries of this range.  */
4886      gad->max = cur + got;
4887      gad->min = fdcur - fd;
4888      gad->fdplt = 0;
4889    
4890      /* If function descriptors took too much space, wrap some of them
4891         around.  */
4892      if (gad->min < wrapmin)
4893        {
4894          gad->max += wrapmin - gad->min;
4895          gad->tmin = gad->min = wrapmin;
4896        }
4897    
4898      /* If GOT entries took too much space, wrap some of them around.
4899         This may well cause gad->min to become lower than wrapmin.  This
4900         will cause a relocation overflow later on, so we don't have to
4901         report it here . */
4902      if ((bfd_vma) gad->max > wrap)
4903        {
4904          gad->min -= gad->max - wrap;
4905          gad->max = wrap;
4906        }
4907    
4908      /* Add TLS descriptors.  */
4909      gad->tmax = gad->max + tlsd;
4910      gad->tmin = gad->min;
4911      gad->tlsdplt = 0;
4912    
4913      /* If TLS descriptors took too much space, wrap an integral number
4914         of them around.  */
4915      if ((bfd_vma) gad->tmax > wrap)
4916        {
4917          bfd_vma wrapsize = gad->tmax - wrap;
4918    
4919          wrapsize += tdescsz / 2;
4920          wrapsize &= ~ tdescsz / 2;
4921    
4922          gad->tmin -= wrapsize;
4923          gad->tmax -= wrapsize;
4924        }
4925    
4926      /* If there is space left and we have function descriptors
4927         referenced in PLT entries that could take advantage of shorter
4928         offsets, place them now.  */
4929      if (fdplt && gad->tmin > wrapmin)
4930        {
4931          bfd_vma fds;
4932    
4933          if ((bfd_vma) (gad->tmin - wrapmin) < fdplt)
4934            fds = gad->tmin - wrapmin;
4935          else
4936            fds = fdplt;
4937    
4938          fdplt -= fds;
4939          gad->min -= fds;
4940          gad->tmin -= fds;
4941          gad->fdplt += fds;
4942        }
4943    
4944      /* If there is more space left, try to place some more function
4945         descriptors for PLT entries.  */
4946      if (fdplt && (bfd_vma) gad->tmax < wrap)
4947        {
4948          bfd_vma fds;
4949    
4950          if ((bfd_vma) (wrap - gad->tmax) < fdplt)
4951            fds = wrap - gad->tmax;
4952          else
4953            fds = fdplt;
4954    
4955          fdplt -= fds;
4956          gad->max += fds;
4957          gad->tmax += fds;
4958          gad->fdplt += fds;
4959        }
4960    
4961      /* If there is space left and we have TLS descriptors referenced in
4962         PLT entries that could take advantage of shorter offsets, place
4963         them now.  */
4964      if (tlsdplt && gad->tmin > wrapmin)
4965        {
4966          bfd_vma tlsds;
4967    
4968          if ((bfd_vma) (gad->tmin - wrapmin) < tlsdplt)
4969            tlsds = (gad->tmin - wrapmin) & ~ (tdescsz / 2);
4970          else
4971            tlsds = tlsdplt;
4972    
4973          tlsdplt -= tlsds;
4974          gad->tmin -= tlsds;
4975          gad->tlsdplt += tlsds;
4976        }
4977    
4978      /* If there is more space left, try to place some more TLS
4979         descriptors for PLT entries.  Although we could try to fit an
4980         additional TLS descriptor with half of it just before before the
4981         wrap point and another right past the wrap point, this might
4982         cause us to run out of space for the next region, so don't do
4983         it.  */
4984      if (tlsdplt && (bfd_vma) gad->tmax < wrap - tdescsz / 2)
4985        {
4986          bfd_vma tlsds;
4987    
4988          if ((bfd_vma) (wrap - gad->tmax) < tlsdplt)
4989            tlsds = (wrap - gad->tmax) & ~ (tdescsz / 2);
4990          else
4991            tlsds = tlsdplt;
4992    
4993          tlsdplt -= tlsds;
4994          gad->tmax += tlsds;
4995          gad->tlsdplt += tlsds;
4996        }
4997    
4998      /* If odd was initially computed as an offset past the wrap point,
4999         wrap it around.  */
5000      if (odd > gad->max)
5001        odd = gad->min + odd - gad->max;
5002    
5003      /* _frvfdpic_get_got_entry() below will always wrap gad->cur if needed
5004         before returning, so do it here too.  This guarantees that,
5005         should cur and fdcur meet at the wrap point, they'll both be
5006         equal to min.  */
5007      if (gad->cur == gad->max)
5008        gad->cur = gad->min;
5009    
5010      /* Ditto for _frvfdpic_get_tlsdesc_entry().  */
5011      gad->tcur = gad->max;
5012      if (gad->tcur == gad->tmax)
5013        gad->tcur = gad->tmin;
5014    
5015      return odd;
5016    }
5017    
5018    /* Compute the location of the next GOT entry, given the allocation
5019       data for a range.  */
5020    
5021    inline static bfd_signed_vma
5022    _frvfdpic_get_got_entry (struct _frvfdpic_dynamic_got_alloc_data *gad)
5023    {
5024      bfd_signed_vma ret;
5025    
5026      if (gad->odd)
5027        {
5028          /* If there was an odd word left behind, use it.  */
5029          ret = gad->odd;
5030          gad->odd = 0;
5031        }
5032      else
5033        {
5034          /* Otherwise, use the word pointed to by cur, reserve the next
5035             as an odd word, and skip to the next pair of words, possibly
5036             wrapping around.  */
5037          ret = gad->cur;
5038          gad->odd = gad->cur + 4;
5039          gad->cur += 8;
5040          if (gad->cur == gad->max)
5041            gad->cur = gad->min;
5042        }
5043    
5044      return ret;
5045    }
5046    
5047    /* Compute the location of the next function descriptor entry in the
5048       GOT, given the allocation data for a range.  */
5049    
5050    inline static bfd_signed_vma
5051    _frvfdpic_get_fd_entry (struct _frvfdpic_dynamic_got_alloc_data *gad)
5052    {
5053      /* If we're at the bottom, wrap around, and only then allocate the
5054         next pair of words.  */
5055      if (gad->fdcur == gad->min)
5056        gad->fdcur = gad->max;
5057      return gad->fdcur -= 8;
5058    }
5059    
5060    /* Compute the location of the next TLS descriptor entry in the GOT,
5061       given the allocation data for a range.  */
5062    inline static bfd_signed_vma
5063    _frvfdpic_get_tlsdesc_entry (struct _frvfdpic_dynamic_got_alloc_data *gad)
5064    {
5065      bfd_signed_vma ret;
5066    
5067      ret = gad->tcur;
5068    
5069      gad->tcur += 8;
5070    
5071      /* If we're at the top of the region, wrap around to the bottom.  */
5072      if (gad->tcur == gad->tmax)
5073        gad->tcur = gad->tmin;
5074    
5075      return ret;
5076    }
5077    
5078    /* Assign GOT offsets for every GOT entry and function descriptor.
5079       Doing everything in a single pass is tricky.  */
5080    
5081    static int
5082    _frvfdpic_assign_got_entries (void **entryp, void *info_)
5083    {
5084      struct frvfdpic_relocs_info *entry = *entryp;
5085      struct _frvfdpic_dynamic_got_plt_info *dinfo = info_;
5086    
5087      if (entry->got12)
5088        entry->got_entry = _frvfdpic_get_got_entry (&dinfo->got12);
5089      else if (entry->gotlos)
5090        entry->got_entry = _frvfdpic_get_got_entry (&dinfo->gotlos);
5091      else if (entry->gothilo)
5092        entry->got_entry = _frvfdpic_get_got_entry (&dinfo->gothilo);
5093    
5094      if (entry->fdgot12)
5095        entry->fdgot_entry = _frvfdpic_get_got_entry (&dinfo->got12);
5096      else if (entry->fdgotlos)
5097        entry->fdgot_entry = _frvfdpic_get_got_entry (&dinfo->gotlos);
5098      else if (entry->fdgothilo)
5099        entry->fdgot_entry = _frvfdpic_get_got_entry (&dinfo->gothilo);
5100    
5101      if (entry->fdgoff12)
5102        entry->fd_entry = _frvfdpic_get_fd_entry (&dinfo->got12);
5103      else if (entry->plt && dinfo->got12.fdplt)
5104        {
5105          dinfo->got12.fdplt -= 8;
5106          entry->fd_entry = _frvfdpic_get_fd_entry (&dinfo->got12);
5107        }
5108      else if (entry->fdgofflos)
5109        entry->fd_entry = _frvfdpic_get_fd_entry (&dinfo->gotlos);
5110      else if (entry->plt && dinfo->gotlos.fdplt)
5111        {
5112          dinfo->gotlos.fdplt -= 8;
5113          entry->fd_entry = _frvfdpic_get_fd_entry (&dinfo->gotlos);
5114        }
5115      else if (entry->plt)
5116        {
5117          dinfo->gothilo.fdplt -= 8;
5118          entry->fd_entry = _frvfdpic_get_fd_entry (&dinfo->gothilo);
5119        }
5120      else if (entry->privfd)
5121        entry->fd_entry = _frvfdpic_get_fd_entry (&dinfo->gothilo);
5122    
5123      if (entry->tlsoff12)
5124        entry->tlsoff_entry = _frvfdpic_get_got_entry (&dinfo->got12);
5125      else if (entry->tlsofflos)
5126        entry->tlsoff_entry = _frvfdpic_get_got_entry (&dinfo->gotlos);
5127      else if (entry->tlsoffhilo)
5128        entry->tlsoff_entry = _frvfdpic_get_got_entry (&dinfo->gothilo);
5129    
5130      if (entry->tlsdesc12)
5131        entry->tlsdesc_entry = _frvfdpic_get_tlsdesc_entry (&dinfo->got12);
5132      else if (entry->tlsplt && dinfo->got12.tlsdplt)
5133        {
5134          dinfo->got12.tlsdplt -= 8;
5135          entry->tlsdesc_entry = _frvfdpic_get_tlsdesc_entry (&dinfo->got12);
5136        }
5137      else if (entry->tlsdesclos)
5138        entry->tlsdesc_entry = _frvfdpic_get_tlsdesc_entry (&dinfo->gotlos);
5139      else if (entry->tlsplt && dinfo->gotlos.tlsdplt)
5140        {
5141          dinfo->gotlos.tlsdplt -= 8;
5142          entry->tlsdesc_entry = _frvfdpic_get_tlsdesc_entry (&dinfo->gotlos);
5143        }
5144      else if (entry->tlsplt)
5145        {
5146          dinfo->gothilo.tlsdplt -= 8;
5147          entry->tlsdesc_entry = _frvfdpic_get_tlsdesc_entry (&dinfo->gothilo);
5148        }
5149      else if (entry->tlsdeschilo)
5150        entry->tlsdesc_entry = _frvfdpic_get_tlsdesc_entry (&dinfo->gothilo);
5151    
5152      return 1;
5153    }
5154    
5155    /* Assign GOT offsets to private function descriptors used by PLT
5156       entries (or referenced by 32-bit offsets), as well as PLT entries
5157       and lazy PLT entries.  */
5158    
5159    static int
5160    _frvfdpic_assign_plt_entries (void **entryp, void *info_)
5161    {
5162      struct frvfdpic_relocs_info *entry = *entryp;
5163      struct _frvfdpic_dynamic_got_plt_info *dinfo = info_;
5164    
5165      if (entry->privfd)
5166        BFD_ASSERT (entry->fd_entry);
5167    
5168      if (entry->plt)
5169        {
5170          int size;
5171    
5172          /* We use the section's raw size to mark the location of the
5173             next PLT entry.  */
5174          entry->plt_entry = frvfdpic_plt_section (dinfo->g.info)->size;
5175    
5176          /* Figure out the length of this PLT entry based on the
5177             addressing mode we need to reach the function descriptor.  */
5178          BFD_ASSERT (entry->fd_entry);
5179          if (entry->fd_entry >= -(1 << (12 - 1))
5180              && entry->fd_entry < (1 << (12 - 1)))
5181            size = 8;
5182          else if (entry->fd_entry >= -(1 << (16 - 1))
5183                   && entry->fd_entry < (1 << (16 - 1)))
5184            size = 12;
5185          else
5186            size = 16;
5187    
5188          frvfdpic_plt_section (dinfo->g.info)->size += size;
5189        }
5190    
5191      if (entry->lazyplt)
5192        {
5193          entry->lzplt_entry = dinfo->g.lzplt;
5194          dinfo->g.lzplt += 8;
5195          /* If this entry is the one that gets the resolver stub, account
5196             for the additional instruction.  */
5197          if (entry->lzplt_entry % FRVFDPIC_LZPLT_BLOCK_SIZE
5198              == FRVFDPIC_LZPLT_RESOLV_LOC)
5199            dinfo->g.lzplt += 4;
5200        }
5201    
5202      if (entry->tlsplt)
5203        {
5204          int size;
5205    
5206          entry->tlsplt_entry
5207            = frvfdpic_plt_section (dinfo->g.info)->size;
5208    
5209          if (dinfo->g.info->executable
5210              && (entry->symndx != -1
5211                  || FRVFDPIC_SYM_LOCAL (dinfo->g.info, entry->d.h)))
5212            {
5213              if ((bfd_signed_vma)entry->addend >= -(1 << (16 - 1))
5214                  /* FIXME: here we use the size of the TLS section
5215                     as an upper bound for the value of the TLS
5216                     symbol, because we may not know the exact value
5217                     yet.  If we get it wrong, we'll just waste a
5218                     word in the PLT, and we should never get even
5219                     close to 32 KiB of TLS anyway.  */
5220                  && elf_hash_table (dinfo->g.info)->tls_sec
5221                  && (elf_hash_table (dinfo->g.info)->tls_sec->size
5222                      + (bfd_signed_vma)(entry->addend) <= (1 << (16 - 1))))
5223                size = 8;
5224              else
5225                size = 12;
5226            }
5227          else if (entry->tlsoff_entry)
5228            {
5229              if (entry->tlsoff_entry >= -(1 << (12 - 1))
5230                  && entry->tlsoff_entry < (1 << (12 - 1)))
5231                size = 8;
5232              else if (entry->tlsoff_entry >= -(1 << (16 - 1))
5233                       && entry->tlsoff_entry < (1 << (16 - 1)))
5234                size = 12;
5235              else
5236                size = 16;
5237            }
5238          else
5239            {
5240              BFD_ASSERT (entry->tlsdesc_entry);
5241    
5242              if (entry->tlsdesc_entry >= -(1 << (12 - 1))
5243                  && entry->tlsdesc_entry < (1 << (12 - 1)))
5244                size = 8;
5245              else if (entry->tlsdesc_entry >= -(1 << (16 - 1))
5246                       && entry->tlsdesc_entry < (1 << (16 - 1)))
5247                size = 12;
5248              else
5249                size = 16;
5250            }
5251          
5252          frvfdpic_plt_section (dinfo->g.info)->size += size;
5253        }
5254    
5255      return 1;
5256    }
5257    
5258    /* Cancel out any effects of calling _frvfdpic_assign_got_entries and
5259       _frvfdpic_assign_plt_entries.  */
5260    
5261    static int
5262    _frvfdpic_reset_got_plt_entries (void **entryp, void *ignore ATTRIBUTE_UNUSED)
5263    {
5264      struct frvfdpic_relocs_info *entry = *entryp;
5265    
5266      entry->got_entry = 0;
5267      entry->fdgot_entry = 0;
5268      entry->fd_entry = 0;
5269      entry->plt_entry = (bfd_vma)-1;
5270      entry->lzplt_entry = (bfd_vma)-1;
5271      entry->tlsoff_entry = 0;
5272      entry->tlsdesc_entry = 0;
5273      entry->tlsplt_entry = (bfd_vma)-1;
5274    
5275      return 1;
5276    }
5277    
5278    /* Follow indirect and warning hash entries so that each got entry
5279       points to the final symbol definition.  P must point to a pointer
5280       to the hash table we're traversing.  Since this traversal may
5281       modify the hash table, we set this pointer to NULL to indicate
5282       we've made a potentially-destructive change to the hash table, so
5283       the traversal must be restarted.  */
5284    static int
5285    _frvfdpic_resolve_final_relocs_info (void **entryp, void *p)
5286    {
5287      struct frvfdpic_relocs_info *entry = *entryp;
5288      htab_t *htab = p;
5289    
5290      if (entry->symndx == -1)
5291        {
5292          struct elf_link_hash_entry *h = entry->d.h;
5293          struct frvfdpic_relocs_info *oentry;
5294    
5295          while (h->root.type == bfd_link_hash_indirect
5296                 || h->root.type == bfd_link_hash_warning)
5297            h = (struct elf_link_hash_entry *)h->root.u.i.link;
5298    
5299          if (entry->d.h == h)
5300            return 1;
5301    
5302          oentry = frvfdpic_relocs_info_for_global (*htab, 0, h, entry->addend,
5303                                                    NO_INSERT);
5304    
5305          if (oentry)
5306            {
5307              /* Merge the two entries.  */
5308              frvfdpic_pic_merge_early_relocs_info (oentry, entry);
5309              htab_clear_slot (*htab, entryp);
5310              return 1;
5311            }
5312    
5313          entry->d.h = h;
5314    
5315          /* If we can't find this entry with the new bfd hash, re-insert
5316             it, and get the traversal restarted.  */
5317          if (! htab_find (*htab, entry))
5318            {
5319              htab_clear_slot (*htab, entryp);
5320              entryp = htab_find_slot (*htab, entry, INSERT);
5321              if (! *entryp)
5322                *entryp = entry;
5323              /* Abort the traversal, since the whole table may have
5324                 moved, and leave it up to the parent to restart the
5325                 process.  */
5326              *(htab_t *)p = NULL;
5327              return 0;
5328            }
5329        }
5330    
5331      return 1;
5332    }
5333    
5334    /* Compute the total size of the GOT, the PLT, the dynamic relocations
5335       section and the rofixup section.  Assign locations for GOT and PLT
5336       entries.  */
5337    
5338    static bfd_boolean
5339    _frvfdpic_size_got_plt (bfd *output_bfd,
5340                            struct _frvfdpic_dynamic_got_plt_info *gpinfop)
5341    {
5342      bfd_signed_vma odd;
5343      bfd_vma limit, tlslimit;
5344      struct bfd_link_info *info = gpinfop->g.info;
5345      bfd *dynobj = elf_hash_table (info)->dynobj;
5346    
5347      memcpy (frvfdpic_dynamic_got_plt_info (info), &gpinfop->g,
5348              sizeof (gpinfop->g));
5349    
5350      odd = 12;
5351      /* Compute the total size taken by entries in the 12-bit and 16-bit
5352         ranges, to tell how many PLT function descriptors we can bring
5353         into the 12-bit range without causing the 16-bit range to
5354         overflow.  */
5355      limit = odd + gpinfop->g.got12 + gpinfop->g.gotlos
5356        + gpinfop->g.fd12 + gpinfop->g.fdlos
5357        + gpinfop->g.tlsd12 + gpinfop->g.tlsdlos;
5358      if (limit < (bfd_vma)1 << 16)
5359        limit = ((bfd_vma)1 << 16) - limit;
5360      else
5361        limit = 0;
5362      if (gpinfop->g.fdplt < limit)
5363        {
5364          tlslimit = (limit - gpinfop->g.fdplt) & ~ (bfd_vma) 8;
5365          limit = gpinfop->g.fdplt;
5366        }
5367      else
5368        tlslimit = 0;
5369      if (gpinfop->g.tlsdplt < tlslimit)
5370        tlslimit = gpinfop->g.tlsdplt;
5371    
5372      /* Determine the ranges of GOT offsets that we can use for each
5373         range of addressing modes.  */
5374      odd = _frvfdpic_compute_got_alloc_data (&gpinfop->got12,
5375                                              0,
5376                                              odd,
5377                                              16,
5378                                              gpinfop->g.got12,
5379                                              gpinfop->g.fd12,
5380                                              limit,
5381                                              gpinfop->g.tlsd12,
5382                                              tlslimit,
5383                                              (bfd_vma)1 << (12-1));
5384      odd = _frvfdpic_compute_got_alloc_data (&gpinfop->gotlos,
5385                                              gpinfop->got12.tmin,
5386                                              odd,
5387                                              gpinfop->got12.tmax,
5388                                              gpinfop->g.gotlos,
5389                                              gpinfop->g.fdlos,
5390                                              gpinfop->g.fdplt
5391                                              - gpinfop->got12.fdplt,
5392                                              gpinfop->g.tlsdlos,
5393                                              gpinfop->g.tlsdplt
5394                                              - gpinfop->got12.tlsdplt,
5395                                              (bfd_vma)1 << (16-1));
5396      odd = _frvfdpic_compute_got_alloc_data (&gpinfop->gothilo,
5397                                              gpinfop->gotlos.tmin,
5398                                              odd,
5399                                              gpinfop->gotlos.tmax,
5400                                              gpinfop->g.gothilo,
5401                                              gpinfop->g.fdhilo,
5402                                              gpinfop->g.fdplt
5403                                              - gpinfop->got12.fdplt
5404                                              - gpinfop->gotlos.fdplt,
5405                                              gpinfop->g.tlsdhilo,
5406                                              gpinfop->g.tlsdplt
5407                                              - gpinfop->got12.tlsdplt
5408                                              - gpinfop->gotlos.tlsdplt,
5409                                              (bfd_vma)1 << (32-1));
5410    
5411      /* Now assign (most) GOT offsets.  */
5412      htab_traverse (frvfdpic_relocs_info (info), _frvfdpic_assign_got_entries,
5413                     gpinfop);
5414    
5415      frvfdpic_got_section (info)->size = gpinfop->gothilo.tmax
5416        - gpinfop->gothilo.tmin
5417        /* If an odd word is the last word of the GOT, we don't need this
5418           word to be part of the GOT.  */
5419        - (odd + 4 == gpinfop->gothilo.tmax ? 4 : 0);
5420      if (frvfdpic_got_section (info)->size == 0)
5421        frvfdpic_got_section (info)->flags |= SEC_EXCLUDE;
5422      else if (frvfdpic_got_section (info)->size == 12
5423               && ! elf_hash_table (info)->dynamic_sections_created)
5424        {
5425          frvfdpic_got_section (info)->flags |= SEC_EXCLUDE;
5426          frvfdpic_got_section (info)->size = 0;
5427        }
5428      /* This will be non-NULL during relaxation.  The assumption is that
5429         the size of one of these sections will never grow, only shrink,
5430         so we can use the larger buffer we allocated before.  */
5431      else if (frvfdpic_got_section (info)->contents == NULL)
5432        {
5433          frvfdpic_got_section (info)->contents =
5434            (bfd_byte *) bfd_zalloc (dynobj,
5435                                     frvfdpic_got_section (info)->size);
5436          if (frvfdpic_got_section (info)->contents == NULL)
5437            return FALSE;
5438        }
5439    
5440      if (frvfdpic_gotrel_section (info))
5441        /* Subtract the number of lzplt entries, since those will generate
5442           relocations in the pltrel section.  */
5443        frvfdpic_gotrel_section (info)->size =
5444          (gpinfop->g.relocs - gpinfop->g.lzplt / 8)
5445          * get_elf_backend_data (output_bfd)->s->sizeof_rel;
5446      else
5447        BFD_ASSERT (gpinfop->g.relocs == 0);
5448      if (frvfdpic_gotrel_section (info)->size == 0)
5449        frvfdpic_gotrel_section (info)->flags |= SEC_EXCLUDE;
5450      else if (frvfdpic_gotrel_section (info)->contents == NULL)
5451        {
5452          frvfdpic_gotrel_section (info)->contents =
5453            (bfd_byte *) bfd_zalloc (dynobj,
5454                                     frvfdpic_gotrel_section (info)->size);
5455          if (frvfdpic_gotrel_section (info)->contents == NULL)
5456            return FALSE;
5457        }
5458    
5459      frvfdpic_gotfixup_section (info)->size = (gpinfop->g.fixups + 1) * 4;
5460      if (frvfdpic_gotfixup_section (info)->size == 0)
5461        frvfdpic_gotfixup_section (info)->flags |= SEC_EXCLUDE;
5462      else if (frvfdpic_gotfixup_section (info)->contents == NULL)
5463        {
5464          frvfdpic_gotfixup_section (info)->contents =
5465            (bfd_byte *) bfd_zalloc (dynobj,
5466                                     frvfdpic_gotfixup_section (info)->size);
5467          if (frvfdpic_gotfixup_section (info)->contents == NULL)
5468            return FALSE;
5469        }
5470    
5471      if (frvfdpic_pltrel_section (info))
5472        {
5473          frvfdpic_pltrel_section (info)->size =
5474            gpinfop->g.lzplt / 8
5475            * get_elf_backend_data (output_bfd)->s->sizeof_rel;
5476          if (frvfdpic_pltrel_section (info)->size == 0)
5477            frvfdpic_pltrel_section (info)->flags |= SEC_EXCLUDE;
5478          else if (frvfdpic_pltrel_section (info)->contents == NULL)
5479            {
5480              frvfdpic_pltrel_section (info)->contents =
5481                (bfd_byte *) bfd_zalloc (dynobj,
5482                                         frvfdpic_pltrel_section (info)->size);
5483              if (frvfdpic_pltrel_section (info)->contents == NULL)
5484                return FALSE;
5485            }
5486        }
5487    
5488      /* Add 4 bytes for every block of at most 65535 lazy PLT entries,
5489         such that there's room for the additional instruction needed to
5490         call the resolver.  Since _frvfdpic_assign_got_entries didn't
5491         account for them, our block size is 4 bytes smaller than the real
5492         block size.  */
5493      if (frvfdpic_plt_section (info))
5494        {
5495          frvfdpic_plt_section (info)->size = gpinfop->g.lzplt
5496            + ((gpinfop->g.lzplt + (FRVFDPIC_LZPLT_BLOCK_SIZE - 4) - 8)
5497               / (FRVFDPIC_LZPLT_BLOCK_SIZE - 4) * 4);
5498        }
5499    
5500      /* Reset it, such that _frvfdpic_assign_plt_entries() can use it to
5501         actually assign lazy PLT entries addresses.  */
5502      gpinfop->g.lzplt = 0;
5503    
5504      /* Save information that we're going to need to generate GOT and PLT
5505         entries.  */
5506      frvfdpic_got_initial_offset (info) = -gpinfop->gothilo.tmin;
5507    
5508      if (get_elf_backend_data (output_bfd)->want_got_sym)
5509        elf_hash_table (info)->hgot->root.u.def.value
5510          = frvfdpic_got_initial_offset (info);
5511    
5512      if (frvfdpic_plt_section (info))
5513        frvfdpic_plt_initial_offset (info) =
5514          frvfdpic_plt_section (info)->size;
5515    
5516      /* Allocate a ret statement at plt_initial_offset, to be used by
5517         locally-resolved TLS descriptors.  */
5518      if (gpinfop->g.tls_ret_refs)
5519        frvfdpic_plt_section (info)->size += 4;
5520    
5521      htab_traverse (frvfdpic_relocs_info (info), _frvfdpic_assign_plt_entries,
5522                     gpinfop);
5523    
5524      /* Allocate the PLT section contents only after
5525         _frvfdpic_assign_plt_entries has a chance to add the size of the
5526         non-lazy PLT entries.  */
5527      if (frvfdpic_plt_section (info))
5528        {
5529          if (frvfdpic_plt_section (info)->size == 0)
5530            frvfdpic_plt_section (info)->flags |= SEC_EXCLUDE;
5531          else if (frvfdpic_plt_section (info)->contents == NULL)
5532            {
5533              frvfdpic_plt_section (info)->contents =
5534                (bfd_byte *) bfd_zalloc (dynobj,
5535                                         frvfdpic_plt_section (info)->size);
5536              if (frvfdpic_plt_section (info)->contents == NULL)
5537                return FALSE;
5538            }
5539        }
5540    
5541      return TRUE;
5542    }
5543    
5544    /* Set the sizes of the dynamic sections.  */
5545    
5546    static bfd_boolean
5547    elf32_frvfdpic_size_dynamic_sections (bfd *output_bfd,
5548                                          struct bfd_link_info *info)
5549    {
5550      bfd *dynobj;
5551      asection *s;
5552      struct _frvfdpic_dynamic_got_plt_info gpinfo;
5553    
5554      dynobj = elf_hash_table (info)->dynobj;
5555      BFD_ASSERT (dynobj != NULL);
5556    
5557      if (elf_hash_table (info)->dynamic_sections_created)
5558        {
5559          /* Set the contents of the .interp section to the interpreter.  */
5560          if (info->executable)
5561            {
5562              s = bfd_get_section_by_name (dynobj, ".interp");
5563              BFD_ASSERT (s != NULL);
5564              s->size = sizeof ELF_DYNAMIC_INTERPRETER;
5565              s->contents = (bfd_byte *) ELF_DYNAMIC_INTERPRETER;
5566            }
5567        }
5568    
5569      memset (&gpinfo, 0, sizeof (gpinfo));
5570      gpinfo.g.info = info;
5571    
5572      for (;;)
5573        {
5574          htab_t relocs = frvfdpic_relocs_info (info);
5575    
5576          htab_traverse (relocs, _frvfdpic_resolve_final_relocs_info, &relocs);
5577    
5578          if (relocs == frvfdpic_relocs_info (info))
5579            break;
5580        }
5581    
5582      htab_traverse (frvfdpic_relocs_info (info), _frvfdpic_count_got_plt_entries,
5583                     &gpinfo.g);
5584    
5585      /* Allocate space to save the summary information, we're going to
5586         use it if we're doing relaxations.  */
5587      frvfdpic_dynamic_got_plt_info (info) = bfd_alloc (dynobj, sizeof (gpinfo.g));
5588    
5589      if (!_frvfdpic_size_got_plt (output_bfd, &gpinfo))
5590        return FALSE;
5591    
5592      if (elf_hash_table (info)->dynamic_sections_created)
5593        {
5594          if (frvfdpic_got_section (info)->size)
5595            if (!_bfd_elf_add_dynamic_entry (info, DT_PLTGOT, 0))
5596              return FALSE;
5597    
5598          if (frvfdpic_pltrel_section (info)->size)
5599            if (!_bfd_elf_add_dynamic_entry (info, DT_PLTRELSZ, 0)
5600                || !_bfd_elf_add_dynamic_entry (info, DT_PLTREL, DT_REL)
5601                || !_bfd_elf_add_dynamic_entry (info, DT_JMPREL, 0))
5602              return FALSE;
5603    
5604          if (frvfdpic_gotrel_section (info)->size)
5605            if (!_bfd_elf_add_dynamic_entry (info, DT_REL, 0)
5606                || !_bfd_elf_add_dynamic_entry (info, DT_RELSZ, 0)
5607                || !_bfd_elf_add_dynamic_entry (info, DT_RELENT,
5608                                                sizeof (Elf32_External_Rel)))
5609              return FALSE;
5610        }
5611    
5612      return TRUE;
5613    }
5614    
5615    static bfd_boolean
5616    elf32_frvfdpic_always_size_sections (bfd *output_bfd,
5617                                         struct bfd_link_info *info)
5618    {
5619      if (!info->relocatable)
5620        {
5621          struct elf_link_hash_entry *h;
5622          asection *sec;
5623    
5624          /* Force a PT_GNU_STACK segment to be created.  */
5625          if (! elf_tdata (output_bfd)->stack_flags)
5626            elf_tdata (output_bfd)->stack_flags = PF_R | PF_W | PF_X;
5627    
5628          /* Define __stacksize if it's not defined yet.  */
5629          h = elf_link_hash_lookup (elf_hash_table (info), "__stacksize",
5630                                    FALSE, FALSE, FALSE);
5631          if (! h || h->root.type != bfd_link_hash_defined
5632              || h->type != STT_OBJECT
5633              || !h->def_regular)
5634            {
5635              struct bfd_link_hash_entry *bh = NULL;
5636    
5637              if (!(_bfd_generic_link_add_one_symbol
5638                    (info, output_bfd, "__stacksize",
5639                     BSF_GLOBAL, bfd_abs_section_ptr, DEFAULT_STACK_SIZE,
5640                     (const char *) NULL, FALSE,
5641                     get_elf_backend_data (output_bfd)->collect, &bh)))
5642                return FALSE;
5643    
5644              h = (struct elf_link_hash_entry *) bh;
5645              h->def_regular = 1;
5646              h->type = STT_OBJECT;
5647              /* This one must NOT be hidden.  */
5648            }
5649    
5650          /* Create a stack section, and set its alignment.  */
5651          sec = bfd_make_section (output_bfd, ".stack");
5652    
5653          if (sec == NULL
5654              || ! bfd_set_section_alignment (output_bfd, sec, 3))
5655            return FALSE;
5656        }
5657    
5658      return TRUE;
5659    }
5660    
5661    /* Look for opportunities to relax TLS relocations.  We can assume
5662       we're linking the main executable or a static-tls library, since
5663       otherwise we wouldn't have got here.  */
5664    
5665    static int
5666    _frvfdpic_relax_got_plt_entries (void **entryp, void *dinfo_)
5667    {
5668      struct frvfdpic_relocs_info *entry = *entryp;
5669      struct _frvfdpic_dynamic_got_info *dinfo = dinfo_;
5670    
5671      _frvfdpic_relax_tls_entries (entry, dinfo, TRUE);
5672    
5673      return 1;
5674    }
5675    
5676    static bfd_boolean
5677    elf32_frvfdpic_relax_section (bfd *abfd ATTRIBUTE_UNUSED, asection *sec,
5678                                  struct bfd_link_info *info, bfd_boolean *again)
5679    {
5680      struct _frvfdpic_dynamic_got_plt_info gpinfo;
5681    
5682      /* If we return early, we didn't change anything.  */
5683      *again = FALSE;
5684    
5685      /* We'll do our thing when requested to relax the GOT section.  */
5686      if (sec != frvfdpic_got_section (info))
5687        return TRUE;
5688    
5689      /* We can only relax when linking the main executable or a library
5690         that can't be dlopened.  */
5691      if (! info->executable && ! (info->flags & DF_STATIC_TLS))
5692        return TRUE;
5693    
5694      /* If there isn't a TLS section for this binary, we can't do
5695         anything about its TLS relocations (it probably doesn't have
5696         any.  */
5697      if (elf_hash_table (info)->tls_sec == NULL)
5698        return TRUE;
5699    
5700      memset (&gpinfo, 0, sizeof (gpinfo));
5701      memcpy (&gpinfo.g, frvfdpic_dynamic_got_plt_info (info), sizeof (gpinfo.g));
5702    
5703      /* Now look for opportunities to relax, adjusting the GOT usage
5704         as needed.  */
5705      htab_traverse (frvfdpic_relocs_info (info),
5706                     _frvfdpic_relax_got_plt_entries,
5707                     &gpinfo.g);
5708    
5709      /* If we changed anything, reset and re-assign GOT and PLT entries.  */
5710      if (memcmp (frvfdpic_dynamic_got_plt_info (info),
5711                  &gpinfo.g, sizeof (gpinfo.g)) != 0)
5712        {
5713          /* Clear GOT and PLT assignments.  */
5714          htab_traverse (frvfdpic_relocs_info (info),
5715                         _frvfdpic_reset_got_plt_entries,
5716                         NULL);
5717    
5718          /* The owner of the TLS section is the output bfd.  There should
5719             be a better way to get to it.  */
5720          if (!_frvfdpic_size_got_plt (elf_hash_table (info)->tls_sec->owner,
5721                                       &gpinfo))
5722            return FALSE;
5723    
5724          /* Repeat until we don't make any further changes.  We could fail to
5725             introduce changes in a round if, for example, the 12-bit range is
5726             full, but we later release some space by getting rid of TLS
5727             descriptors in it.  We have to repeat the whole process because
5728             we might have changed the size of a section processed before this
5729             one.  */
5730          *again = TRUE;
5731        }
5732    
5733      return TRUE;
5734    }
5735    
5736    static bfd_boolean
5737    elf32_frvfdpic_modify_segment_map (bfd *output_bfd,
5738                                       struct bfd_link_info *info)
5739    {
5740      struct elf_segment_map *m;
5741    
5742      /* objcopy and strip preserve what's already there using
5743         elf32_frvfdpic_copy_private_bfd_data ().  */
5744      if (! info)
5745        return TRUE;
5746    
5747      for (m = elf_tdata (output_bfd)->segment_map; m != NULL; m = m->next)
5748        if (m->p_type == PT_GNU_STACK)
5749          break;
5750    
5751      if (m)
5752        {
5753          asection *sec = bfd_get_section_by_name (output_bfd, ".stack");
5754          struct elf_link_hash_entry *h;
5755    
5756          if (sec)
5757            {
5758              /* Obtain the pointer to the __stacksize symbol.  */
5759              h = elf_link_hash_lookup (elf_hash_table (info), "__stacksize",
5760                                        FALSE, FALSE, FALSE);
5761              while (h->root.type == bfd_link_hash_indirect
5762                     || h->root.type == bfd_link_hash_warning)
5763                h = (struct elf_link_hash_entry *)h->root.u.i.link;
5764              BFD_ASSERT (h->root.type == bfd_link_hash_defined);
5765    
5766              /* Set the section size from the symbol value.  We
5767                 intentionally ignore the symbol section.  */
5768              if (h->root.type == bfd_link_hash_defined)
5769                sec->size = h->root.u.def.value;
5770              else
5771                sec->size = DEFAULT_STACK_SIZE;
5772    
5773              /* Add the stack section to the PT_GNU_STACK segment,
5774                 such that its size and alignment requirements make it
5775                 to the segment.  */
5776              m->sections[m->count] = sec;
5777              m->count++;
5778            }
5779        }
5780    
5781      return TRUE;
5782    }
5783    
5784    /* Fill in code and data in dynamic sections.  */
5785    
5786    static bfd_boolean
5787    elf32_frv_finish_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
5788                                       struct bfd_link_info *info ATTRIBUTE_UNUSED)
5789    {
5790      /* Nothing to be done for non-FDPIC.  */
5791      return TRUE;
5792    }
5793    
5794    static bfd_boolean
5795    elf32_frvfdpic_finish_dynamic_sections (bfd *output_bfd,
5796                                            struct bfd_link_info *info)
5797    {
5798      bfd *dynobj;
5799      asection *sdyn;
5800    
5801      dynobj = elf_hash_table (info)->dynobj;
5802    
5803      if (frvfdpic_dynamic_got_plt_info (info))
5804        {
5805          BFD_ASSERT (frvfdpic_dynamic_got_plt_info (info)->tls_ret_refs == 0);
5806        }
5807      if (frvfdpic_got_section (info))
5808        {
5809          BFD_ASSERT (frvfdpic_gotrel_section (info)->size
5810                      == (frvfdpic_gotrel_section (info)->reloc_count
5811                          * sizeof (Elf32_External_Rel)));
5812    
5813          if (frvfdpic_gotfixup_section (info))
5814            {
5815              struct elf_link_hash_entry *hgot = elf_hash_table (info)->hgot;
5816              bfd_vma got_value = hgot->root.u.def.value
5817                + hgot->root.u.def.section->output_section->vma
5818                + hgot->root.u.def.section->output_offset;
5819              struct bfd_link_hash_entry *hend;
5820    
5821              _frvfdpic_add_rofixup (output_bfd, frvfdpic_gotfixup_section (info),
5822                                     got_value, 0);
5823    
5824              if (frvfdpic_gotfixup_section (info)->size
5825                  != (frvfdpic_gotfixup_section (info)->reloc_count * 4))
5826                {
5827                error:
5828                  (*_bfd_error_handler)
5829                    ("LINKER BUG: .rofixup section size mismatch");
5830                  return FALSE;
5831                }
5832    
5833              hend = bfd_link_hash_lookup (info->hash, "__ROFIXUP_END__",
5834                                           FALSE, FALSE, TRUE);
5835              if (hend
5836                  && (hend->type == bfd_link_hash_defined
5837                      || hend->type == bfd_link_hash_defweak))
5838                {
5839                  bfd_vma value =
5840                    frvfdpic_gotfixup_section (info)->output_section->vma
5841                    + frvfdpic_gotfixup_section (info)->output_offset
5842                    + frvfdpic_gotfixup_section (info)->size
5843                    - hend->u.def.section->output_section->vma
5844                    - hend->u.def.section->output_offset;
5845                  BFD_ASSERT (hend->u.def.value == value);
5846                  if (hend->u.def.value != value)
5847                    goto error;
5848                }
5849            }
5850        }
5851      if (frvfdpic_pltrel_section (info))
5852        {
5853          BFD_ASSERT (frvfdpic_pltrel_section (info)->size
5854                      == (frvfdpic_pltrel_section (info)->reloc_count
5855                          * sizeof (Elf32_External_Rel)));
5856        }
5857    
5858    
5859      if (elf_hash_table (info)->dynamic_sections_created)
5860        {
5861          Elf32_External_Dyn * dyncon;
5862          Elf32_External_Dyn * dynconend;
5863    
5864          sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
5865    
5866          BFD_ASSERT (sdyn != NULL);
5867    
5868          dyncon = (Elf32_External_Dyn *) sdyn->contents;
5869          dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
5870    
5871          for (; dyncon < dynconend; dyncon++)
5872            {
5873              Elf_Internal_Dyn dyn;
5874    
5875              bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
5876    
5877              switch (dyn.d_tag)
5878                {
5879                default:
5880                  break;
5881    
5882                case DT_PLTGOT:
5883                  dyn.d_un.d_ptr = frvfdpic_got_section (info)->output_section->vma
5884                    + frvfdpic_got_section (info)->output_offset
5885                    + frvfdpic_got_initial_offset (info);
5886                  bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
5887                  break;
5888    
5889                case DT_JMPREL:
5890                  dyn.d_un.d_ptr = frvfdpic_pltrel_section (info)
5891                    ->output_section->vma
5892                    + frvfdpic_pltrel_section (info)->output_offset;
5893                  bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
5894                  break;
5895    
5896                case DT_PLTRELSZ:
5897                  dyn.d_un.d_val = frvfdpic_pltrel_section (info)->size;
5898                  bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
5899                  break;
5900                }
5901            }
5902        }
5903    
5904      return TRUE;
5905    }
5906    
5907    /* Adjust a symbol defined by a dynamic object and referenced by a
5908       regular object.  */
5909    
5910    static bfd_boolean
5911    elf32_frvfdpic_adjust_dynamic_symbol
5912    (struct bfd_link_info *info ATTRIBUTE_UNUSED,
5913     struct elf_link_hash_entry *h ATTRIBUTE_UNUSED)
5914    {
5915      bfd * dynobj;
5916    
5917      dynobj = elf_hash_table (info)->dynobj;
5918    
5919      /* Make sure we know what is going on here.  */
5920      BFD_ASSERT (dynobj != NULL
5921                  && (h->u.weakdef != NULL
5922                      || (h->def_dynamic
5923                          && h->ref_regular
5924                          && !h->def_regular)));
5925    
5926      /* If this is a weak symbol, and there is a real definition, the
5927         processor independent code will have arranged for us to see the
5928         real definition first, and we can just use the same value.  */
5929      if (h->u.weakdef != NULL)
5930        {
5931          BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
5932                      || h->u.weakdef->root.type == bfd_link_hash_defweak);
5933          h->root.u.def.section = h->u.weakdef->root.u.def.section;
5934          h->root.u.def.value = h->u.weakdef->root.u.def.value;
5935        }
5936    
5937      return TRUE;
5938    }
5939    
5940    /* Perform any actions needed for dynamic symbols.  */
5941    
5942    static bfd_boolean
5943    elf32_frvfdpic_finish_dynamic_symbol
5944    (bfd *output_bfd ATTRIBUTE_UNUSED,
5945     struct bfd_link_info *info ATTRIBUTE_UNUSED,
5946     struct elf_link_hash_entry *h ATTRIBUTE_UNUSED,
5947     Elf_Internal_Sym *sym ATTRIBUTE_UNUSED)
5948    {
5949      return TRUE;
5950    }
5951    
5952    /* Decide whether to attempt to turn absptr or lsda encodings in
5953       shared libraries into pcrel within the given input section.  */
5954    
5955    static bfd_boolean
5956    frvfdpic_elf_use_relative_eh_frame
5957    (bfd *input_bfd ATTRIBUTE_UNUSED,
5958     struct bfd_link_info *info ATTRIBUTE_UNUSED,
5959     asection *eh_frame_section ATTRIBUTE_UNUSED)
5960    {
5961      /* We can't use PC-relative encodings in FDPIC binaries, in general.  */
5962      return FALSE;
5963    }
5964    
5965    /* Adjust the contents of an eh_frame_hdr section before they're output.  */
5966    
5967    static bfd_byte
5968    frvfdpic_elf_encode_eh_address (bfd *abfd,
5969                                    struct bfd_link_info *info,
5970                                    asection *osec, bfd_vma offset,
5971                                    asection *loc_sec, bfd_vma loc_offset,
5972                                    bfd_vma *encoded)
5973    {
5974      struct elf_link_hash_entry *h;
5975    
5976      h = elf_hash_table (info)->hgot;
5977      BFD_ASSERT (h && h->root.type == bfd_link_hash_defined);
5978    
5979      if (! h || (_frvfdpic_osec_to_segment (abfd, osec)
5980                  == _frvfdpic_osec_to_segment (abfd, loc_sec->output_section)))
5981        return _bfd_elf_encode_eh_address (abfd, info, osec, offset,
5982                                           loc_sec, loc_offset, encoded);
5983    
5984      BFD_ASSERT (_frvfdpic_osec_to_segment (abfd, osec)
5985                  == (_frvfdpic_osec_to_segment
5986                      (abfd, h->root.u.def.section->output_section)));
5987    
5988      *encoded = osec->vma + offset
5989        - (h->root.u.def.value
5990           + h->root.u.def.section->output_section->vma
5991           + h->root.u.def.section->output_offset);
5992    
5993      return DW_EH_PE_datarel | DW_EH_PE_sdata4;
5994    }
5995    
5996  /* Look through the relocs for a section during the first phase.  /* Look through the relocs for a section during the first phase.
5997     Since we don't do .gots or .plts, we just need to consider the  
5998     virtual table relocs for gc.  */     Besides handling virtual table relocs for gc, we have to deal with
5999       all sorts of PIC-related relocations.  We describe below the
6000  static boolean     general plan on how to handle such relocations, even though we only
6001       collect information at this point, storing them in hash tables for
6002       perusal of later passes.
6003    
6004       32 relocations are propagated to the linker output when creating
6005       position-independent output.  LO16 and HI16 relocations are not
6006       supposed to be encountered in this case.
6007    
6008       LABEL16 should always be resolvable by the linker, since it's only
6009       used by branches.
6010    
6011       LABEL24, on the other hand, is used by calls.  If it turns out that
6012       the target of a call is a dynamic symbol, a PLT entry must be
6013       created for it, which triggers the creation of a private function
6014       descriptor and, unless lazy binding is disabled, a lazy PLT entry.
6015    
6016       GPREL relocations require the referenced symbol to be in the same
6017       segment as _gp, but this can only be checked later.
6018    
6019       All GOT, GOTOFF and FUNCDESC relocations require a .got section to
6020       exist.  LABEL24 might as well, since it may require a PLT entry,
6021       that will require a got.
6022    
6023       Non-FUNCDESC GOT relocations require a GOT entry to be created
6024       regardless of whether the symbol is dynamic.  However, since a
6025       global symbol that turns out to not be exported may have the same
6026       address of a non-dynamic symbol, we don't assign GOT entries at
6027       this point, such that we can share them in this case.  A relocation
6028       for the GOT entry always has to be created, be it to offset a
6029       private symbol by the section load address, be it to get the symbol
6030       resolved dynamically.
6031    
6032       FUNCDESC GOT relocations require a GOT entry to be created, and
6033       handled as if a FUNCDESC relocation was applied to the GOT entry in
6034       an object file.
6035    
6036       FUNCDESC relocations referencing a symbol that turns out to NOT be
6037       dynamic cause a private function descriptor to be created.  The
6038       FUNCDESC relocation then decays to a 32 relocation that points at
6039       the private descriptor.  If the symbol is dynamic, the FUNCDESC
6040       relocation is propagated to the linker output, such that the
6041       dynamic linker creates the canonical descriptor, pointing to the
6042       dynamically-resolved definition of the function.
6043    
6044       Non-FUNCDESC GOTOFF relocations must always refer to non-dynamic
6045       symbols that are assigned to the same segment as the GOT, but we
6046       can only check this later, after we know the complete set of
6047       symbols defined and/or exported.
6048    
6049       FUNCDESC GOTOFF relocations require a function descriptor to be
6050       created and, unless lazy binding is disabled or the symbol is not
6051       dynamic, a lazy PLT entry.  Since we can't tell at this point
6052       whether a symbol is going to be dynamic, we have to decide later
6053       whether to create a lazy PLT entry or bind the descriptor directly
6054       to the private function.
6055    
6056       FUNCDESC_VALUE relocations are not supposed to be present in object
6057       files, but they may very well be simply propagated to the linker
6058       output, since they have no side effect.
6059    
6060    
6061       A function descriptor always requires a FUNCDESC_VALUE relocation.
6062       Whether it's in .plt.rel or not depends on whether lazy binding is
6063       enabled and on whether the referenced symbol is dynamic.
6064    
6065       The existence of a lazy PLT requires the resolverStub lazy PLT
6066       entry to be present.
6067    
6068    
6069       As for assignment of GOT, PLT and lazy PLT entries, and private
6070       descriptors, we might do them all sequentially, but we can do
6071       better than that.  For example, we can place GOT entries and
6072       private function descriptors referenced using 12-bit operands
6073       closer to the PIC register value, such that these relocations don't
6074       overflow.  Those that are only referenced with LO16 relocations
6075       could come next, but we may as well place PLT-required function
6076       descriptors in the 12-bit range to make them shorter.  Symbols
6077       referenced with LO16/HI16 may come next, but we may place
6078       additional function descriptors in the 16-bit range if we can
6079       reliably tell that we've already placed entries that are ever
6080       referenced with only LO16.  PLT entries are therefore generated as
6081       small as possible, while not introducing relocation overflows in
6082       GOT or FUNCDESC_GOTOFF relocations.  Lazy PLT entries could be
6083       generated before or after PLT entries, but not intermingled with
6084       them, such that we can have more lazy PLT entries in range for a
6085       branch to the resolverStub.  The resolverStub should be emitted at
6086       the most distant location from the first lazy PLT entry such that
6087       it's still in range for a branch, or closer, if there isn't a need
6088       for so many lazy PLT entries.  Additional lazy PLT entries may be
6089       emitted after the resolverStub, as long as branches are still in
6090       range.  If the branch goes out of range, longer lazy PLT entries
6091       are emitted.
6092    
6093       We could further optimize PLT and lazy PLT entries by giving them
6094       priority in assignment to closer-to-gr17 locations depending on the
6095       number of occurrences of references to them (assuming a function
6096       that's called more often is more important for performance, so its
6097       PLT entry should be faster), or taking hints from the compiler.
6098       Given infinite time and money... :-)  */
6099    
6100    static bfd_boolean
6101  elf32_frv_check_relocs (abfd, info, sec, relocs)  elf32_frv_check_relocs (abfd, info, sec, relocs)
6102       bfd *abfd;       bfd *abfd;
6103       struct bfd_link_info *info;       struct bfd_link_info *info;
# Line 940  elf32_frv_check_relocs (abfd, info, sec, Line 6108  elf32_frv_check_relocs (abfd, info, sec,
6108    struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;    struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
6109    const Elf_Internal_Rela *rel;    const Elf_Internal_Rela *rel;
6110    const Elf_Internal_Rela *rel_end;    const Elf_Internal_Rela *rel_end;
6111      bfd *dynobj;
6112    if (info->relocateable)    struct frvfdpic_relocs_info *picrel;
6113      return true;  
6114      if (info->relocatable)
6115        return TRUE;
6116    
6117    symtab_hdr = &elf_tdata (abfd)->symtab_hdr;    symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
6118    sym_hashes = elf_sym_hashes (abfd);    sym_hashes = elf_sym_hashes (abfd);
6119    sym_hashes_end = sym_hashes + symtab_hdr->sh_size/sizeof(Elf32_External_Sym);    sym_hashes_end = sym_hashes + symtab_hdr->sh_size/sizeof(Elf32_External_Sym);
6120    if (!elf_bad_symtab (abfd))    if (!elf_bad_symtab (abfd))
6121      sym_hashes_end -= symtab_hdr->sh_info;      sym_hashes_end -= symtab_hdr->sh_info;
6122    
6123      dynobj = elf_hash_table (info)->dynobj;
6124    rel_end = relocs + sec->reloc_count;    rel_end = relocs + sec->reloc_count;
6125    for (rel = relocs; rel < rel_end; rel++)    for (rel = relocs; rel < rel_end; rel++)
6126      {      {
6127        struct elf_link_hash_entry *h;        struct elf_link_hash_entry *h;
6128        unsigned long r_symndx;        unsigned long r_symndx;
6129    
6130        r_symndx = ELF32_R_SYM (rel->r_info);        r_symndx = ELF32_R_SYM (rel->r_info);
6131        if (r_symndx < symtab_hdr->sh_info)        if (r_symndx < symtab_hdr->sh_info)
6132          h = NULL;          h = NULL;
6133        else        else
6134          h = sym_hashes[r_symndx - symtab_hdr->sh_info];          h = sym_hashes[r_symndx - symtab_hdr->sh_info];
6135    
6136          switch (ELF32_R_TYPE (rel->r_info))
6137            {
6138            case R_FRV_GETTLSOFF:
6139            case R_FRV_TLSDESC_VALUE:
6140            case R_FRV_GOTTLSDESC12:
6141            case R_FRV_GOTTLSDESCHI:
6142            case R_FRV_GOTTLSDESCLO:
6143            case R_FRV_GOTTLSOFF12:
6144            case R_FRV_GOTTLSOFFHI:
6145            case R_FRV_GOTTLSOFFLO:
6146            case R_FRV_TLSOFF:
6147            case R_FRV_GOT12:
6148            case R_FRV_GOTHI:
6149            case R_FRV_GOTLO:
6150            case R_FRV_FUNCDESC_GOT12:
6151            case R_FRV_FUNCDESC_GOTHI:
6152            case R_FRV_FUNCDESC_GOTLO:
6153            case R_FRV_GOTOFF12:
6154            case R_FRV_GOTOFFHI:
6155            case R_FRV_GOTOFFLO:
6156            case R_FRV_FUNCDESC_GOTOFF12:
6157            case R_FRV_FUNCDESC_GOTOFFHI:
6158            case R_FRV_FUNCDESC_GOTOFFLO:
6159            case R_FRV_FUNCDESC:
6160            case R_FRV_FUNCDESC_VALUE:
6161            case R_FRV_TLSMOFF12:
6162            case R_FRV_TLSMOFFHI:
6163            case R_FRV_TLSMOFFLO:
6164            case R_FRV_TLSMOFF:
6165              if (! IS_FDPIC (abfd))
6166                goto bad_reloc;
6167              /* Fall through.  */
6168            case R_FRV_GPREL12:
6169            case R_FRV_GPRELU12:
6170            case R_FRV_GPRELHI:
6171            case R_FRV_GPRELLO:
6172            case R_FRV_LABEL24:
6173            case R_FRV_32:
6174              if (! dynobj)
6175                {
6176                  elf_hash_table (info)->dynobj = dynobj = abfd;
6177                  if (! _frv_create_got_section (abfd, info))
6178                    return FALSE;
6179                }
6180              if (! IS_FDPIC (abfd))
6181                {
6182                  picrel = NULL;
6183                  break;
6184                }
6185              if (h != NULL)
6186                {
6187                  if (h->dynindx == -1)
6188                    switch (ELF_ST_VISIBILITY (h->other))
6189                      {
6190                      case STV_INTERNAL:
6191                      case STV_HIDDEN:
6192                        break;
6193                      default:
6194                        bfd_elf_link_record_dynamic_symbol (info, h);
6195                        break;
6196                      }
6197                  picrel
6198                    = frvfdpic_relocs_info_for_global (frvfdpic_relocs_info (info),
6199                                                       abfd, h,
6200                                                       rel->r_addend, INSERT);
6201                }
6202              else
6203                picrel = frvfdpic_relocs_info_for_local (frvfdpic_relocs_info
6204                                                         (info), abfd, r_symndx,
6205                                                         rel->r_addend, INSERT);
6206              if (! picrel)
6207                return FALSE;
6208              break;
6209    
6210            default:
6211              picrel = NULL;
6212              break;
6213            }
6214    
6215        switch (ELF32_R_TYPE (rel->r_info))        switch (ELF32_R_TYPE (rel->r_info))
6216          {          {
6217            case R_FRV_LABEL24:
6218              if (IS_FDPIC (abfd))
6219                picrel->call = 1;
6220              break;
6221    
6222            case R_FRV_FUNCDESC_VALUE:
6223              picrel->relocsfdv++;
6224              if (bfd_get_section_flags (abfd, sec) & SEC_ALLOC)
6225                picrel->relocs32--;
6226              /* Fall through.  */
6227    
6228            case R_FRV_32:
6229              if (! IS_FDPIC (abfd))
6230                break;
6231    
6232              picrel->sym = 1;
6233              if (bfd_get_section_flags (abfd, sec) & SEC_ALLOC)
6234                picrel->relocs32++;
6235              break;
6236    
6237            case R_FRV_GOT12:
6238              picrel->got12 = 1;
6239              break;
6240    
6241            case R_FRV_GOTHI:
6242            case R_FRV_GOTLO:
6243              picrel->gothilo = 1;
6244              break;
6245    
6246            case R_FRV_FUNCDESC_GOT12:
6247              picrel->fdgot12 = 1;
6248              break;
6249    
6250            case R_FRV_FUNCDESC_GOTHI:
6251            case R_FRV_FUNCDESC_GOTLO:
6252              picrel->fdgothilo = 1;
6253              break;
6254    
6255            case R_FRV_GOTOFF12:
6256            case R_FRV_GOTOFFHI:
6257            case R_FRV_GOTOFFLO:
6258              picrel->gotoff = 1;
6259              break;
6260    
6261            case R_FRV_FUNCDESC_GOTOFF12:
6262              picrel->fdgoff12 = 1;
6263              break;
6264    
6265            case R_FRV_FUNCDESC_GOTOFFHI:
6266            case R_FRV_FUNCDESC_GOTOFFLO:
6267              picrel->fdgoffhilo = 1;
6268              break;
6269    
6270            case R_FRV_FUNCDESC:
6271              picrel->fd = 1;
6272              picrel->relocsfd++;
6273              break;
6274    
6275            case R_FRV_GETTLSOFF:
6276              picrel->tlsplt = 1;
6277              break;
6278    
6279            case R_FRV_TLSDESC_VALUE:
6280              picrel->relocstlsd++;
6281              goto bad_reloc;
6282              
6283            case R_FRV_GOTTLSDESC12:
6284              picrel->tlsdesc12 = 1;
6285              break;
6286    
6287            case R_FRV_GOTTLSDESCHI:
6288            case R_FRV_GOTTLSDESCLO:
6289              picrel->tlsdeschilo = 1;
6290              break;
6291    
6292            case R_FRV_TLSMOFF12:
6293            case R_FRV_TLSMOFFHI:
6294            case R_FRV_TLSMOFFLO:
6295            case R_FRV_TLSMOFF:
6296              break;
6297    
6298            case R_FRV_GOTTLSOFF12:
6299              picrel->tlsoff12 = 1;
6300              info->flags |= DF_STATIC_TLS;
6301              break;
6302              
6303            case R_FRV_GOTTLSOFFHI:
6304            case R_FRV_GOTTLSOFFLO:
6305              picrel->tlsoffhilo = 1;
6306              info->flags |= DF_STATIC_TLS;
6307              break;
6308              
6309            case R_FRV_TLSOFF:
6310              picrel->relocstlsoff++;
6311              info->flags |= DF_STATIC_TLS;
6312              goto bad_reloc;
6313    
6314          /* This relocation describes the C++ object vtable hierarchy.          /* This relocation describes the C++ object vtable hierarchy.
6315             Reconstruct it for later use during GC.  */             Reconstruct it for later use during GC.  */
6316          case R_FRV_GNU_VTINHERIT:          case R_FRV_GNU_VTINHERIT:
6317            if (!_bfd_elf32_gc_record_vtinherit (abfd, sec, h, rel->r_offset))            if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
6318              return false;              return FALSE;
6319            break;            break;
6320    
6321          /* This relocation describes which C++ vtable entries are actually          /* This relocation describes which C++ vtable entries are actually
6322             used.  Record for later use during GC.  */             used.  Record for later use during GC.  */
6323          case R_FRV_GNU_VTENTRY:          case R_FRV_GNU_VTENTRY:
6324            if (!_bfd_elf32_gc_record_vtentry (abfd, sec, h, rel->r_addend))            if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
6325              return false;              return FALSE;
6326            break;            break;
6327    
6328            case R_FRV_LABEL16:
6329            case R_FRV_LO16:
6330            case R_FRV_HI16:
6331            case R_FRV_GPREL12:
6332            case R_FRV_GPRELU12:
6333            case R_FRV_GPREL32:
6334            case R_FRV_GPRELHI:
6335            case R_FRV_GPRELLO:
6336            case R_FRV_TLSDESC_RELAX:
6337            case R_FRV_GETTLSOFF_RELAX:
6338            case R_FRV_TLSOFF_RELAX:
6339              break;
6340    
6341            default:
6342            bad_reloc:
6343              (*_bfd_error_handler)
6344                (_("%B: unsupported relocation type %i"),
6345                 abfd, ELF32_R_TYPE (rel->r_info));
6346              return FALSE;
6347          }          }
6348      }      }
6349    
6350    return true;    return TRUE;
6351  }  }
6352    
6353    
# Line 993  elf32_frv_machine (abfd) Line 6360  elf32_frv_machine (abfd)
6360    switch (elf_elfheader (abfd)->e_flags & EF_FRV_CPU_MASK)    switch (elf_elfheader (abfd)->e_flags & EF_FRV_CPU_MASK)
6361      {      {
6362      default:                break;      default:                break;
6363        case EF_FRV_CPU_FR550:  return bfd_mach_fr550;
6364      case EF_FRV_CPU_FR500:  return bfd_mach_fr500;      case EF_FRV_CPU_FR500:  return bfd_mach_fr500;
6365        case EF_FRV_CPU_FR450:  return bfd_mach_fr450;
6366        case EF_FRV_CPU_FR405:  return bfd_mach_fr400;
6367      case EF_FRV_CPU_FR400:  return bfd_mach_fr400;      case EF_FRV_CPU_FR400:  return bfd_mach_fr400;
6368      case EF_FRV_CPU_FR300:  return bfd_mach_fr300;      case EF_FRV_CPU_FR300:  return bfd_mach_fr300;
6369      case EF_FRV_CPU_SIMPLE: return bfd_mach_frvsimple;      case EF_FRV_CPU_SIMPLE: return bfd_mach_frvsimple;
# Line 1005  elf32_frv_machine (abfd) Line 6375  elf32_frv_machine (abfd)
6375    
6376  /* Set the right machine number for a FRV ELF file.  */  /* Set the right machine number for a FRV ELF file.  */
6377    
6378  static boolean  static bfd_boolean
6379  elf32_frv_object_p (abfd)  elf32_frv_object_p (abfd)
6380       bfd *abfd;       bfd *abfd;
6381  {  {
6382    bfd_default_set_arch_mach (abfd, bfd_arch_frv, elf32_frv_machine (abfd));    bfd_default_set_arch_mach (abfd, bfd_arch_frv, elf32_frv_machine (abfd));
6383    return true;    return (((elf_elfheader (abfd)->e_flags & EF_FRV_FDPIC) != 0)
6384              == (IS_FDPIC (abfd)));
6385  }  }
6386    
6387  /* Function to set the ELF flag bits.  */  /* Function to set the ELF flag bits.  */
6388    
6389  static boolean  static bfd_boolean
6390  frv_elf_set_private_flags (abfd, flags)  frv_elf_set_private_flags (abfd, flags)
6391       bfd *abfd;       bfd *abfd;
6392       flagword flags;       flagword flags;
6393  {  {
6394    elf_elfheader (abfd)->e_flags = flags;    elf_elfheader (abfd)->e_flags = flags;
6395    elf_flags_init (abfd) = true;    elf_flags_init (abfd) = TRUE;
6396    return true;    return TRUE;
6397  }  }
6398    
6399  /* Copy backend specific data from one object module to another.  */  /* Copy backend specific data from one object module to another.  */
6400    
6401  static boolean  static bfd_boolean
6402  frv_elf_copy_private_bfd_data (ibfd, obfd)  frv_elf_copy_private_bfd_data (ibfd, obfd)
6403       bfd *ibfd;       bfd *ibfd;
6404       bfd *obfd;       bfd *obfd;
6405  {  {
6406    if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour    if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
6407        || bfd_get_flavour (obfd) != bfd_target_elf_flavour)        || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
6408      return true;      return TRUE;
6409    
6410    BFD_ASSERT (!elf_flags_init (obfd)    BFD_ASSERT (!elf_flags_init (obfd)
6411                || elf_elfheader (obfd)->e_flags == elf_elfheader (ibfd)->e_flags);                || elf_elfheader (obfd)->e_flags == elf_elfheader (ibfd)->e_flags);
6412    
6413    elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;    elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
6414    elf_flags_init (obfd) = true;    elf_flags_init (obfd) = TRUE;
6415    return true;    return TRUE;
6416    }
6417    
6418    /* Return true if the architecture described by elf header flag
6419       EXTENSION is an extension of the architecture described by BASE.  */
6420    
6421    static bfd_boolean
6422    frv_elf_arch_extension_p (flagword base, flagword extension)
6423    {
6424      if (base == extension)
6425        return TRUE;
6426    
6427      /* CPU_GENERIC code can be merged with code for a specific
6428         architecture, in which case the result is marked as being
6429         for the specific architecture.  Everything is therefore
6430         an extension of CPU_GENERIC.  */
6431      if (base == EF_FRV_CPU_GENERIC)
6432        return TRUE;
6433    
6434      if (extension == EF_FRV_CPU_FR450)
6435        if (base == EF_FRV_CPU_FR400 || base == EF_FRV_CPU_FR405)
6436          return TRUE;
6437    
6438      if (extension == EF_FRV_CPU_FR405)
6439        if (base == EF_FRV_CPU_FR400)
6440          return TRUE;
6441    
6442      return FALSE;
6443    }
6444    
6445    static bfd_boolean
6446    elf32_frvfdpic_copy_private_bfd_data (bfd *ibfd, bfd *obfd)
6447    {
6448      unsigned i;
6449    
6450      if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
6451          || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
6452        return TRUE;
6453    
6454      if (! frv_elf_copy_private_bfd_data (ibfd, obfd))
6455        return FALSE;
6456    
6457      if (! elf_tdata (ibfd) || ! elf_tdata (ibfd)->phdr
6458          || ! elf_tdata (obfd) || ! elf_tdata (obfd)->phdr)
6459        return TRUE;
6460    
6461      /* Copy the stack size.  */
6462      for (i = 0; i < elf_elfheader (ibfd)->e_phnum; i++)
6463        if (elf_tdata (ibfd)->phdr[i].p_type == PT_GNU_STACK)
6464          {
6465            Elf_Internal_Phdr *iphdr = &elf_tdata (ibfd)->phdr[i];
6466    
6467            for (i = 0; i < elf_elfheader (obfd)->e_phnum; i++)
6468              if (elf_tdata (obfd)->phdr[i].p_type == PT_GNU_STACK)
6469                {
6470                  memcpy (&elf_tdata (obfd)->phdr[i], iphdr, sizeof (*iphdr));
6471    
6472                  /* Rewrite the phdrs, since we're only called after they
6473                     were first written.  */
6474                  if (bfd_seek (obfd, (bfd_signed_vma) get_elf_backend_data (obfd)
6475                                ->s->sizeof_ehdr, SEEK_SET) != 0
6476                      || get_elf_backend_data (obfd)->s
6477                      ->write_out_phdrs (obfd, elf_tdata (obfd)->phdr,
6478                                         elf_elfheader (obfd)->e_phnum) != 0)
6479                    return FALSE;
6480                  break;
6481                }
6482    
6483            break;
6484          }
6485    
6486      return TRUE;
6487  }  }
6488    
6489  /* Merge backend specific data from an object file to the output  /* Merge backend specific data from an object file to the output
6490     object file when linking.  */     object file when linking.  */
6491    
6492  static boolean  static bfd_boolean
6493  frv_elf_merge_private_bfd_data (ibfd, obfd)  frv_elf_merge_private_bfd_data (ibfd, obfd)
6494       bfd *ibfd;       bfd *ibfd;
6495       bfd *obfd;       bfd *obfd;
6496  {  {
6497    flagword old_flags, old_partial;    flagword old_flags, old_partial;
6498    flagword new_flags, new_partial;    flagword new_flags, new_partial;
6499    boolean error = false;    bfd_boolean error = FALSE;
6500    char new_opt[80];    char new_opt[80];
6501    char old_opt[80];    char old_opt[80];
6502    
# Line 1062  frv_elf_merge_private_bfd_data (ibfd, ob Line 6504  frv_elf_merge_private_bfd_data (ibfd, ob
6504    new_flags = elf_elfheader (ibfd)->e_flags;    new_flags = elf_elfheader (ibfd)->e_flags;
6505    old_flags = elf_elfheader (obfd)->e_flags;    old_flags = elf_elfheader (obfd)->e_flags;
6506    
6507      if (new_flags & EF_FRV_FDPIC)
6508        new_flags &= ~EF_FRV_PIC;
6509    
6510  #ifdef DEBUG  #ifdef DEBUG
6511    (*_bfd_error_handler) ("old_flags = 0x%.8lx, new_flags = 0x%.8lx, init = %s, filename = %s",    (*_bfd_error_handler) ("old_flags = 0x%.8lx, new_flags = 0x%.8lx, init = %s, filename = %s",
6512                           old_flags, new_flags, elf_flags_init (obfd) ? "yes" : "no",                           old_flags, new_flags, elf_flags_init (obfd) ? "yes" : "no",
# Line 1070  frv_elf_merge_private_bfd_data (ibfd, ob Line 6515  frv_elf_merge_private_bfd_data (ibfd, ob
6515    
6516    if (!elf_flags_init (obfd))                   /* First call, no flags set.  */    if (!elf_flags_init (obfd))                   /* First call, no flags set.  */
6517      {      {
6518        elf_flags_init (obfd) = true;        elf_flags_init (obfd) = TRUE;
6519        old_flags = new_flags;        old_flags = new_flags;
6520      }      }
6521    
# Line 1212  frv_elf_merge_private_bfd_data (ibfd, ob Line 6657  frv_elf_merge_private_bfd_data (ibfd, ob
6657              {              {
6658                old_flags &= ~ EF_FRV_PIC_FLAGS;                old_flags &= ~ EF_FRV_PIC_FLAGS;
6659  #ifndef FRV_NO_PIC_ERROR  #ifndef FRV_NO_PIC_ERROR
6660                error = true;                error = TRUE;
6661                (*_bfd_error_handler)                (*_bfd_error_handler)
6662                  (_("%s: compiled with %s and linked with modules that use non-pic relocations"),                  (_("%s: compiled with %s and linked with modules that use non-pic relocations"),
6663                   bfd_get_filename (ibfd),                   bfd_get_filename (ibfd),
# Line 1225  frv_elf_merge_private_bfd_data (ibfd, ob Line 6670  frv_elf_merge_private_bfd_data (ibfd, ob
6670           the generic cpu).  */           the generic cpu).  */
6671        new_partial = (new_flags & EF_FRV_CPU_MASK);        new_partial = (new_flags & EF_FRV_CPU_MASK);
6672        old_partial = (old_flags & EF_FRV_CPU_MASK);        old_partial = (old_flags & EF_FRV_CPU_MASK);
6673        if (new_partial == old_partial)        if (frv_elf_arch_extension_p (new_partial, old_partial))
         ;  
   
       else if (new_partial == EF_FRV_CPU_GENERIC)  
6674          ;          ;
6675    
6676        else if (old_partial == EF_FRV_CPU_GENERIC)        else if (frv_elf_arch_extension_p (old_partial, new_partial))
6677          old_flags = (old_flags & ~EF_FRV_CPU_MASK) | new_partial;          old_flags = (old_flags & ~EF_FRV_CPU_MASK) | new_partial;
6678    
6679        else        else
# Line 1241  frv_elf_merge_private_bfd_data (ibfd, ob Line 6683  frv_elf_merge_private_bfd_data (ibfd, ob
6683              default:                 strcat (new_opt, " -mcpu=?");      break;              default:                 strcat (new_opt, " -mcpu=?");      break;
6684              case EF_FRV_CPU_GENERIC: strcat (new_opt, " -mcpu=frv");    break;              case EF_FRV_CPU_GENERIC: strcat (new_opt, " -mcpu=frv");    break;
6685              case EF_FRV_CPU_SIMPLE:  strcat (new_opt, " -mcpu=simple"); break;              case EF_FRV_CPU_SIMPLE:  strcat (new_opt, " -mcpu=simple"); break;
6686                case EF_FRV_CPU_FR550:   strcat (new_opt, " -mcpu=fr550");  break;
6687              case EF_FRV_CPU_FR500:   strcat (new_opt, " -mcpu=fr500");  break;              case EF_FRV_CPU_FR500:   strcat (new_opt, " -mcpu=fr500");  break;
6688                case EF_FRV_CPU_FR450:   strcat (new_opt, " -mcpu=fr450");  break;
6689                case EF_FRV_CPU_FR405:   strcat (new_opt, " -mcpu=fr405");  break;
6690              case EF_FRV_CPU_FR400:   strcat (new_opt, " -mcpu=fr400");  break;              case EF_FRV_CPU_FR400:   strcat (new_opt, " -mcpu=fr400");  break;
6691              case EF_FRV_CPU_FR300:   strcat (new_opt, " -mcpu=fr300");  break;              case EF_FRV_CPU_FR300:   strcat (new_opt, " -mcpu=fr300");  break;
6692              case EF_FRV_CPU_TOMCAT:  strcat (new_opt, " -mcpu=tomcat"); break;              case EF_FRV_CPU_TOMCAT:  strcat (new_opt, " -mcpu=tomcat"); break;
# Line 1252  frv_elf_merge_private_bfd_data (ibfd, ob Line 6697  frv_elf_merge_private_bfd_data (ibfd, ob
6697              default:                 strcat (old_opt, " -mcpu=?");      break;              default:                 strcat (old_opt, " -mcpu=?");      break;
6698              case EF_FRV_CPU_GENERIC: strcat (old_opt, " -mcpu=frv");    break;              case EF_FRV_CPU_GENERIC: strcat (old_opt, " -mcpu=frv");    break;
6699              case EF_FRV_CPU_SIMPLE:  strcat (old_opt, " -mcpu=simple"); break;              case EF_FRV_CPU_SIMPLE:  strcat (old_opt, " -mcpu=simple"); break;
6700                case EF_FRV_CPU_FR550:   strcat (old_opt, " -mcpu=fr550");  break;
6701              case EF_FRV_CPU_FR500:   strcat (old_opt, " -mcpu=fr500");  break;              case EF_FRV_CPU_FR500:   strcat (old_opt, " -mcpu=fr500");  break;
6702                case EF_FRV_CPU_FR450:   strcat (old_opt, " -mcpu=fr450");  break;
6703                case EF_FRV_CPU_FR405:   strcat (old_opt, " -mcpu=fr405");  break;
6704              case EF_FRV_CPU_FR400:   strcat (old_opt, " -mcpu=fr400");  break;              case EF_FRV_CPU_FR400:   strcat (old_opt, " -mcpu=fr400");  break;
6705              case EF_FRV_CPU_FR300:   strcat (old_opt, " -mcpu=fr300");  break;              case EF_FRV_CPU_FR300:   strcat (old_opt, " -mcpu=fr300");  break;
6706              case EF_FRV_CPU_TOMCAT:  strcat (old_opt, " -mcpu=tomcat"); break;              case EF_FRV_CPU_TOMCAT:  strcat (old_opt, " -mcpu=tomcat"); break;
6707              }              }
6708          }          }
6709          
6710        /* Print out any mismatches from above.  */        /* Print out any mismatches from above.  */
6711        if (new_opt[0])        if (new_opt[0])
6712          {          {
6713            error = true;            error = TRUE;
6714            (*_bfd_error_handler)            (*_bfd_error_handler)
6715              (_("%s: compiled with %s and linked with modules compiled with %s"),              (_("%s: compiled with %s and linked with modules compiled with %s"),
6716               bfd_get_filename (ibfd), new_opt, old_opt);               bfd_get_filename (ibfd), new_opt, old_opt);
# Line 1274  frv_elf_merge_private_bfd_data (ibfd, ob Line 6722  frv_elf_merge_private_bfd_data (ibfd, ob
6722        if (new_partial != old_partial)        if (new_partial != old_partial)
6723          {          {
6724            old_flags |= new_partial;            old_flags |= new_partial;
6725            error = true;            error = TRUE;
6726            (*_bfd_error_handler)            (*_bfd_error_handler)
6727              (_("%s: uses different unknown e_flags (0x%lx) fields than previous modules (0x%lx)"),              (_("%s: uses different unknown e_flags (0x%lx) fields than previous modules (0x%lx)"),
6728               bfd_get_filename (ibfd), (long)new_partial, (long)old_partial);               bfd_get_filename (ibfd), (long)new_partial, (long)old_partial);
# Line 1291  frv_elf_merge_private_bfd_data (ibfd, ob Line 6739  frv_elf_merge_private_bfd_data (ibfd, ob
6739    if (old_partial != (old_flags & EF_FRV_CPU_MASK))    if (old_partial != (old_flags & EF_FRV_CPU_MASK))
6740      bfd_default_set_arch_mach (obfd, bfd_arch_frv, elf32_frv_machine (obfd));      bfd_default_set_arch_mach (obfd, bfd_arch_frv, elf32_frv_machine (obfd));
6741    
6742      if (((new_flags & EF_FRV_FDPIC) == 0)
6743          != (! IS_FDPIC (ibfd)))
6744        {
6745          error = TRUE;
6746          if (IS_FDPIC (obfd))
6747            (*_bfd_error_handler)
6748              (_("%s: cannot link non-fdpic object file into fdpic executable"),
6749               bfd_get_filename (ibfd));
6750          else
6751            (*_bfd_error_handler)
6752              (_("%s: cannot link fdpic object file into non-fdpic executable"),
6753               bfd_get_filename (ibfd));
6754        }
6755    
6756    if (error)    if (error)
6757      bfd_set_error (bfd_error_bad_value);      bfd_set_error (bfd_error_bad_value);
6758    
# Line 1298  frv_elf_merge_private_bfd_data (ibfd, ob Line 6760  frv_elf_merge_private_bfd_data (ibfd, ob
6760  }  }
6761    
6762    
6763  boolean  bfd_boolean
6764  frv_elf_print_private_bfd_data (abfd, ptr)  frv_elf_print_private_bfd_data (abfd, ptr)
6765       bfd *abfd;       bfd *abfd;
6766       PTR ptr;       PTR ptr;
# Line 1318  frv_elf_print_private_bfd_data (abfd, pt Line 6780  frv_elf_print_private_bfd_data (abfd, pt
6780      {      {
6781      default:                                                    break;      default:                                                    break;
6782      case EF_FRV_CPU_SIMPLE: fprintf (file, " -mcpu=simple");    break;      case EF_FRV_CPU_SIMPLE: fprintf (file, " -mcpu=simple");    break;
6783        case EF_FRV_CPU_FR550:  fprintf (file, " -mcpu=fr550");     break;
6784      case EF_FRV_CPU_FR500:  fprintf (file, " -mcpu=fr500");     break;      case EF_FRV_CPU_FR500:  fprintf (file, " -mcpu=fr500");     break;
6785        case EF_FRV_CPU_FR450:  fprintf (file, " -mcpu=fr450");     break;
6786        case EF_FRV_CPU_FR405:  fprintf (file, " -mcpu=fr405");     break;
6787      case EF_FRV_CPU_FR400:  fprintf (file, " -mcpu=fr400");     break;      case EF_FRV_CPU_FR400:  fprintf (file, " -mcpu=fr400");     break;
6788      case EF_FRV_CPU_FR300:  fprintf (file, " -mcpu=fr300");     break;      case EF_FRV_CPU_FR300:  fprintf (file, " -mcpu=fr300");     break;
6789      case EF_FRV_CPU_TOMCAT: fprintf (file, " -mcpu=tomcat");    break;      case EF_FRV_CPU_TOMCAT: fprintf (file, " -mcpu=tomcat");    break;
# Line 1361  frv_elf_print_private_bfd_data (abfd, pt Line 6826  frv_elf_print_private_bfd_data (abfd, pt
6826    if (flags & EF_FRV_BIGPIC)    if (flags & EF_FRV_BIGPIC)
6827      fprintf (file, " -fPIC");      fprintf (file, " -fPIC");
6828    
6829      if (flags & EF_FRV_LIBPIC)
6830        fprintf (file, " -mlibrary-pic");
6831    
6832      if (flags & EF_FRV_FDPIC)
6833        fprintf (file, " -mfdpic");
6834    
6835    if (flags & EF_FRV_NON_PIC_RELOCS)    if (flags & EF_FRV_NON_PIC_RELOCS)
6836      fprintf (file, " non-pic relocations");      fprintf (file, " non-pic relocations");
6837    
# Line 1368  frv_elf_print_private_bfd_data (abfd, pt Line 6839  frv_elf_print_private_bfd_data (abfd, pt
6839      fprintf (file, " -G0");      fprintf (file, " -G0");
6840    
6841    fputc ('\n', file);    fputc ('\n', file);
6842    return true;    return TRUE;
6843  }  }
6844    
6845    
# Line 1379  frv_elf_print_private_bfd_data (abfd, pt Line 6850  frv_elf_print_private_bfd_data (abfd, pt
6850  #define TARGET_BIG_SYM          bfd_elf32_frv_vec  #define TARGET_BIG_SYM          bfd_elf32_frv_vec
6851  #define TARGET_BIG_NAME         "elf32-frv"  #define TARGET_BIG_NAME         "elf32-frv"
6852    
 #define elf_info_to_howto_rel                   NULL  
6853  #define elf_info_to_howto                       frv_info_to_howto_rela  #define elf_info_to_howto                       frv_info_to_howto_rela
6854  #define elf_backend_relocate_section            elf32_frv_relocate_section  #define elf_backend_relocate_section            elf32_frv_relocate_section
6855  #define elf_backend_gc_mark_hook                elf32_frv_gc_mark_hook  #define elf_backend_gc_mark_hook                elf32_frv_gc_mark_hook
# Line 1389  frv_elf_print_private_bfd_data (abfd, pt Line 6859  frv_elf_print_private_bfd_data (abfd, pt
6859  #define elf_backend_add_symbol_hook             elf32_frv_add_symbol_hook  #define elf_backend_add_symbol_hook             elf32_frv_add_symbol_hook
6860    
6861  #define elf_backend_can_gc_sections             1  #define elf_backend_can_gc_sections             1
6862    #define elf_backend_rela_normal                 1
6863    
6864  #define bfd_elf32_bfd_reloc_type_lookup         frv_reloc_type_lookup  #define bfd_elf32_bfd_reloc_type_lookup         frv_reloc_type_lookup
6865  #define bfd_elf32_bfd_set_private_flags         frv_elf_set_private_flags  #define bfd_elf32_bfd_set_private_flags         frv_elf_set_private_flags
# Line 1396  frv_elf_print_private_bfd_data (abfd, pt Line 6867  frv_elf_print_private_bfd_data (abfd, pt
6867  #define bfd_elf32_bfd_merge_private_bfd_data    frv_elf_merge_private_bfd_data  #define bfd_elf32_bfd_merge_private_bfd_data    frv_elf_merge_private_bfd_data
6868  #define bfd_elf32_bfd_print_private_bfd_data    frv_elf_print_private_bfd_data  #define bfd_elf32_bfd_print_private_bfd_data    frv_elf_print_private_bfd_data
6869    
6870    #define elf_backend_want_got_sym        1
6871    #define elf_backend_got_header_size     0
6872    #define elf_backend_want_got_plt        0
6873    #define elf_backend_plt_readonly        1
6874    #define elf_backend_want_plt_sym        0
6875    #define elf_backend_plt_header_size     0
6876    
6877    #define elf_backend_finish_dynamic_sections \
6878                    elf32_frv_finish_dynamic_sections
6879    
6880    #include "elf32-target.h"
6881    
6882    #undef ELF_MAXPAGESIZE
6883    #define ELF_MAXPAGESIZE         0x4000
6884    
6885    #undef TARGET_BIG_SYM
6886    #define TARGET_BIG_SYM          bfd_elf32_frvfdpic_vec
6887    #undef TARGET_BIG_NAME
6888    #define TARGET_BIG_NAME         "elf32-frvfdpic"
6889    #undef  elf32_bed
6890    #define elf32_bed               elf32_frvfdpic_bed
6891    
6892    #undef elf_info_to_howto_rel
6893    #define elf_info_to_howto_rel   frvfdpic_info_to_howto_rel
6894    
6895    #undef bfd_elf32_bfd_link_hash_table_create
6896    #define bfd_elf32_bfd_link_hash_table_create \
6897                    frvfdpic_elf_link_hash_table_create
6898    #undef elf_backend_always_size_sections
6899    #define elf_backend_always_size_sections \
6900                    elf32_frvfdpic_always_size_sections
6901    #undef elf_backend_modify_segment_map
6902    #define elf_backend_modify_segment_map \
6903                    elf32_frvfdpic_modify_segment_map
6904    #undef bfd_elf32_bfd_copy_private_bfd_data
6905    #define bfd_elf32_bfd_copy_private_bfd_data \
6906                    elf32_frvfdpic_copy_private_bfd_data
6907    
6908    #undef elf_backend_create_dynamic_sections
6909    #define elf_backend_create_dynamic_sections \
6910                    elf32_frvfdpic_create_dynamic_sections
6911    #undef elf_backend_adjust_dynamic_symbol
6912    #define elf_backend_adjust_dynamic_symbol \
6913                    elf32_frvfdpic_adjust_dynamic_symbol
6914    #undef elf_backend_size_dynamic_sections
6915    #define elf_backend_size_dynamic_sections \
6916                    elf32_frvfdpic_size_dynamic_sections
6917    #undef bfd_elf32_bfd_relax_section
6918    #define bfd_elf32_bfd_relax_section \
6919      elf32_frvfdpic_relax_section
6920    #undef elf_backend_finish_dynamic_symbol
6921    #define elf_backend_finish_dynamic_symbol \
6922                    elf32_frvfdpic_finish_dynamic_symbol
6923    #undef elf_backend_finish_dynamic_sections
6924    #define elf_backend_finish_dynamic_sections \
6925                    elf32_frvfdpic_finish_dynamic_sections
6926    
6927    #undef elf_backend_can_make_relative_eh_frame
6928    #define elf_backend_can_make_relative_eh_frame \
6929                    frvfdpic_elf_use_relative_eh_frame
6930    #undef elf_backend_can_make_lsda_relative_eh_frame
6931    #define elf_backend_can_make_lsda_relative_eh_frame \
6932                    frvfdpic_elf_use_relative_eh_frame
6933    #undef elf_backend_encode_eh_address
6934    #define elf_backend_encode_eh_address \
6935                    frvfdpic_elf_encode_eh_address
6936    
6937    #undef elf_backend_may_use_rel_p
6938    #define elf_backend_may_use_rel_p       1
6939    #undef elf_backend_may_use_rela_p
6940    #define elf_backend_may_use_rela_p      1
6941    /* We use REL for dynamic relocations only.  */
6942    #undef elf_backend_default_use_rela_p
6943    #define elf_backend_default_use_rela_p  1
6944    
6945    #undef elf_backend_omit_section_dynsym
6946    #define elf_backend_omit_section_dynsym _frvfdpic_link_omit_section_dynsym
6947    
6948  #include "elf32-target.h"  #include "elf32-target.h"

Legend:
Removed from v.1.1.1.1  
changed lines
  Added in v.1.2

savannah-hackers-public@gnu.org
ViewVC Help
Powered by ViewVC 1.1.26