1*fae548d3Szrj /* .eh_frame section optimization.
2*fae548d3Szrj Copyright (C) 2001-2020 Free Software Foundation, Inc.
3*fae548d3Szrj Written by Jakub Jelinek <jakub@redhat.com>.
4*fae548d3Szrj
5*fae548d3Szrj This file is part of BFD, the Binary File Descriptor library.
6*fae548d3Szrj
7*fae548d3Szrj This program is free software; you can redistribute it and/or modify
8*fae548d3Szrj it under the terms of the GNU General Public License as published by
9*fae548d3Szrj the Free Software Foundation; either version 3 of the License, or
10*fae548d3Szrj (at your option) any later version.
11*fae548d3Szrj
12*fae548d3Szrj This program is distributed in the hope that it will be useful,
13*fae548d3Szrj but WITHOUT ANY WARRANTY; without even the implied warranty of
14*fae548d3Szrj MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15*fae548d3Szrj GNU General Public License for more details.
16*fae548d3Szrj
17*fae548d3Szrj You should have received a copy of the GNU General Public License
18*fae548d3Szrj along with this program; if not, write to the Free Software
19*fae548d3Szrj Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20*fae548d3Szrj MA 02110-1301, USA. */
21*fae548d3Szrj
22*fae548d3Szrj #include "sysdep.h"
23*fae548d3Szrj #include "bfd.h"
24*fae548d3Szrj #include "libbfd.h"
25*fae548d3Szrj #include "elf-bfd.h"
26*fae548d3Szrj #include "dwarf2.h"
27*fae548d3Szrj
28*fae548d3Szrj #define EH_FRAME_HDR_SIZE 8
29*fae548d3Szrj
30*fae548d3Szrj struct cie
31*fae548d3Szrj {
32*fae548d3Szrj unsigned int length;
33*fae548d3Szrj unsigned int hash;
34*fae548d3Szrj unsigned char version;
35*fae548d3Szrj unsigned char local_personality;
36*fae548d3Szrj char augmentation[20];
37*fae548d3Szrj bfd_vma code_align;
38*fae548d3Szrj bfd_signed_vma data_align;
39*fae548d3Szrj bfd_vma ra_column;
40*fae548d3Szrj bfd_vma augmentation_size;
41*fae548d3Szrj union {
42*fae548d3Szrj struct elf_link_hash_entry *h;
43*fae548d3Szrj struct {
44*fae548d3Szrj unsigned int bfd_id;
45*fae548d3Szrj unsigned int index;
46*fae548d3Szrj } sym;
47*fae548d3Szrj unsigned int reloc_index;
48*fae548d3Szrj } personality;
49*fae548d3Szrj struct eh_cie_fde *cie_inf;
50*fae548d3Szrj unsigned char per_encoding;
51*fae548d3Szrj unsigned char lsda_encoding;
52*fae548d3Szrj unsigned char fde_encoding;
53*fae548d3Szrj unsigned char initial_insn_length;
54*fae548d3Szrj unsigned char can_make_lsda_relative;
55*fae548d3Szrj unsigned char initial_instructions[50];
56*fae548d3Szrj };
57*fae548d3Szrj
58*fae548d3Szrj
59*fae548d3Szrj
60*fae548d3Szrj /* If *ITER hasn't reached END yet, read the next byte into *RESULT and
61*fae548d3Szrj move onto the next byte. Return true on success. */
62*fae548d3Szrj
63*fae548d3Szrj static inline bfd_boolean
read_byte(bfd_byte ** iter,bfd_byte * end,unsigned char * result)64*fae548d3Szrj read_byte (bfd_byte **iter, bfd_byte *end, unsigned char *result)
65*fae548d3Szrj {
66*fae548d3Szrj if (*iter >= end)
67*fae548d3Szrj return FALSE;
68*fae548d3Szrj *result = *((*iter)++);
69*fae548d3Szrj return TRUE;
70*fae548d3Szrj }
71*fae548d3Szrj
72*fae548d3Szrj /* Move *ITER over LENGTH bytes, or up to END, whichever is closer.
73*fae548d3Szrj Return true it was possible to move LENGTH bytes. */
74*fae548d3Szrj
75*fae548d3Szrj static inline bfd_boolean
skip_bytes(bfd_byte ** iter,bfd_byte * end,bfd_size_type length)76*fae548d3Szrj skip_bytes (bfd_byte **iter, bfd_byte *end, bfd_size_type length)
77*fae548d3Szrj {
78*fae548d3Szrj if ((bfd_size_type) (end - *iter) < length)
79*fae548d3Szrj {
80*fae548d3Szrj *iter = end;
81*fae548d3Szrj return FALSE;
82*fae548d3Szrj }
83*fae548d3Szrj *iter += length;
84*fae548d3Szrj return TRUE;
85*fae548d3Szrj }
86*fae548d3Szrj
87*fae548d3Szrj /* Move *ITER over an leb128, stopping at END. Return true if the end
88*fae548d3Szrj of the leb128 was found. */
89*fae548d3Szrj
90*fae548d3Szrj static bfd_boolean
skip_leb128(bfd_byte ** iter,bfd_byte * end)91*fae548d3Szrj skip_leb128 (bfd_byte **iter, bfd_byte *end)
92*fae548d3Szrj {
93*fae548d3Szrj unsigned char byte;
94*fae548d3Szrj do
95*fae548d3Szrj if (!read_byte (iter, end, &byte))
96*fae548d3Szrj return FALSE;
97*fae548d3Szrj while (byte & 0x80);
98*fae548d3Szrj return TRUE;
99*fae548d3Szrj }
100*fae548d3Szrj
101*fae548d3Szrj /* Like skip_leb128, but treat the leb128 as an unsigned value and
102*fae548d3Szrj store it in *VALUE. */
103*fae548d3Szrj
104*fae548d3Szrj static bfd_boolean
read_uleb128(bfd_byte ** iter,bfd_byte * end,bfd_vma * value)105*fae548d3Szrj read_uleb128 (bfd_byte **iter, bfd_byte *end, bfd_vma *value)
106*fae548d3Szrj {
107*fae548d3Szrj bfd_byte *start, *p;
108*fae548d3Szrj
109*fae548d3Szrj start = *iter;
110*fae548d3Szrj if (!skip_leb128 (iter, end))
111*fae548d3Szrj return FALSE;
112*fae548d3Szrj
113*fae548d3Szrj p = *iter;
114*fae548d3Szrj *value = *--p;
115*fae548d3Szrj while (p > start)
116*fae548d3Szrj *value = (*value << 7) | (*--p & 0x7f);
117*fae548d3Szrj
118*fae548d3Szrj return TRUE;
119*fae548d3Szrj }
120*fae548d3Szrj
121*fae548d3Szrj /* Like read_uleb128, but for signed values. */
122*fae548d3Szrj
123*fae548d3Szrj static bfd_boolean
read_sleb128(bfd_byte ** iter,bfd_byte * end,bfd_signed_vma * value)124*fae548d3Szrj read_sleb128 (bfd_byte **iter, bfd_byte *end, bfd_signed_vma *value)
125*fae548d3Szrj {
126*fae548d3Szrj bfd_byte *start, *p;
127*fae548d3Szrj
128*fae548d3Szrj start = *iter;
129*fae548d3Szrj if (!skip_leb128 (iter, end))
130*fae548d3Szrj return FALSE;
131*fae548d3Szrj
132*fae548d3Szrj p = *iter;
133*fae548d3Szrj *value = ((*--p & 0x7f) ^ 0x40) - 0x40;
134*fae548d3Szrj while (p > start)
135*fae548d3Szrj *value = (*value << 7) | (*--p & 0x7f);
136*fae548d3Szrj
137*fae548d3Szrj return TRUE;
138*fae548d3Szrj }
139*fae548d3Szrj
140*fae548d3Szrj /* Return 0 if either encoding is variable width, or not yet known to bfd. */
141*fae548d3Szrj
142*fae548d3Szrj static
get_DW_EH_PE_width(int encoding,int ptr_size)143*fae548d3Szrj int get_DW_EH_PE_width (int encoding, int ptr_size)
144*fae548d3Szrj {
145*fae548d3Szrj /* DW_EH_PE_ values of 0x60 and 0x70 weren't defined at the time .eh_frame
146*fae548d3Szrj was added to bfd. */
147*fae548d3Szrj if ((encoding & 0x60) == 0x60)
148*fae548d3Szrj return 0;
149*fae548d3Szrj
150*fae548d3Szrj switch (encoding & 7)
151*fae548d3Szrj {
152*fae548d3Szrj case DW_EH_PE_udata2: return 2;
153*fae548d3Szrj case DW_EH_PE_udata4: return 4;
154*fae548d3Szrj case DW_EH_PE_udata8: return 8;
155*fae548d3Szrj case DW_EH_PE_absptr: return ptr_size;
156*fae548d3Szrj default:
157*fae548d3Szrj break;
158*fae548d3Szrj }
159*fae548d3Szrj
160*fae548d3Szrj return 0;
161*fae548d3Szrj }
162*fae548d3Szrj
163*fae548d3Szrj #define get_DW_EH_PE_signed(encoding) (((encoding) & DW_EH_PE_signed) != 0)
164*fae548d3Szrj
165*fae548d3Szrj /* Read a width sized value from memory. */
166*fae548d3Szrj
167*fae548d3Szrj static bfd_vma
read_value(bfd * abfd,bfd_byte * buf,int width,int is_signed)168*fae548d3Szrj read_value (bfd *abfd, bfd_byte *buf, int width, int is_signed)
169*fae548d3Szrj {
170*fae548d3Szrj bfd_vma value;
171*fae548d3Szrj
172*fae548d3Szrj switch (width)
173*fae548d3Szrj {
174*fae548d3Szrj case 2:
175*fae548d3Szrj if (is_signed)
176*fae548d3Szrj value = bfd_get_signed_16 (abfd, buf);
177*fae548d3Szrj else
178*fae548d3Szrj value = bfd_get_16 (abfd, buf);
179*fae548d3Szrj break;
180*fae548d3Szrj case 4:
181*fae548d3Szrj if (is_signed)
182*fae548d3Szrj value = bfd_get_signed_32 (abfd, buf);
183*fae548d3Szrj else
184*fae548d3Szrj value = bfd_get_32 (abfd, buf);
185*fae548d3Szrj break;
186*fae548d3Szrj case 8:
187*fae548d3Szrj if (is_signed)
188*fae548d3Szrj value = bfd_get_signed_64 (abfd, buf);
189*fae548d3Szrj else
190*fae548d3Szrj value = bfd_get_64 (abfd, buf);
191*fae548d3Szrj break;
192*fae548d3Szrj default:
193*fae548d3Szrj BFD_FAIL ();
194*fae548d3Szrj return 0;
195*fae548d3Szrj }
196*fae548d3Szrj
197*fae548d3Szrj return value;
198*fae548d3Szrj }
199*fae548d3Szrj
200*fae548d3Szrj /* Store a width sized value to memory. */
201*fae548d3Szrj
202*fae548d3Szrj static void
write_value(bfd * abfd,bfd_byte * buf,bfd_vma value,int width)203*fae548d3Szrj write_value (bfd *abfd, bfd_byte *buf, bfd_vma value, int width)
204*fae548d3Szrj {
205*fae548d3Szrj switch (width)
206*fae548d3Szrj {
207*fae548d3Szrj case 2: bfd_put_16 (abfd, value, buf); break;
208*fae548d3Szrj case 4: bfd_put_32 (abfd, value, buf); break;
209*fae548d3Szrj case 8: bfd_put_64 (abfd, value, buf); break;
210*fae548d3Szrj default: BFD_FAIL ();
211*fae548d3Szrj }
212*fae548d3Szrj }
213*fae548d3Szrj
214*fae548d3Szrj /* Return one if C1 and C2 CIEs can be merged. */
215*fae548d3Szrj
216*fae548d3Szrj static int
cie_eq(const void * e1,const void * e2)217*fae548d3Szrj cie_eq (const void *e1, const void *e2)
218*fae548d3Szrj {
219*fae548d3Szrj const struct cie *c1 = (const struct cie *) e1;
220*fae548d3Szrj const struct cie *c2 = (const struct cie *) e2;
221*fae548d3Szrj
222*fae548d3Szrj if (c1->hash == c2->hash
223*fae548d3Szrj && c1->length == c2->length
224*fae548d3Szrj && c1->version == c2->version
225*fae548d3Szrj && c1->local_personality == c2->local_personality
226*fae548d3Szrj && strcmp (c1->augmentation, c2->augmentation) == 0
227*fae548d3Szrj && strcmp (c1->augmentation, "eh") != 0
228*fae548d3Szrj && c1->code_align == c2->code_align
229*fae548d3Szrj && c1->data_align == c2->data_align
230*fae548d3Szrj && c1->ra_column == c2->ra_column
231*fae548d3Szrj && c1->augmentation_size == c2->augmentation_size
232*fae548d3Szrj && memcmp (&c1->personality, &c2->personality,
233*fae548d3Szrj sizeof (c1->personality)) == 0
234*fae548d3Szrj && (c1->cie_inf->u.cie.u.sec->output_section
235*fae548d3Szrj == c2->cie_inf->u.cie.u.sec->output_section)
236*fae548d3Szrj && c1->per_encoding == c2->per_encoding
237*fae548d3Szrj && c1->lsda_encoding == c2->lsda_encoding
238*fae548d3Szrj && c1->fde_encoding == c2->fde_encoding
239*fae548d3Szrj && c1->initial_insn_length == c2->initial_insn_length
240*fae548d3Szrj && c1->initial_insn_length <= sizeof (c1->initial_instructions)
241*fae548d3Szrj && memcmp (c1->initial_instructions,
242*fae548d3Szrj c2->initial_instructions,
243*fae548d3Szrj c1->initial_insn_length) == 0)
244*fae548d3Szrj return 1;
245*fae548d3Szrj
246*fae548d3Szrj return 0;
247*fae548d3Szrj }
248*fae548d3Szrj
249*fae548d3Szrj static hashval_t
cie_hash(const void * e)250*fae548d3Szrj cie_hash (const void *e)
251*fae548d3Szrj {
252*fae548d3Szrj const struct cie *c = (const struct cie *) e;
253*fae548d3Szrj return c->hash;
254*fae548d3Szrj }
255*fae548d3Szrj
256*fae548d3Szrj static hashval_t
cie_compute_hash(struct cie * c)257*fae548d3Szrj cie_compute_hash (struct cie *c)
258*fae548d3Szrj {
259*fae548d3Szrj hashval_t h = 0;
260*fae548d3Szrj size_t len;
261*fae548d3Szrj h = iterative_hash_object (c->length, h);
262*fae548d3Szrj h = iterative_hash_object (c->version, h);
263*fae548d3Szrj h = iterative_hash (c->augmentation, strlen (c->augmentation) + 1, h);
264*fae548d3Szrj h = iterative_hash_object (c->code_align, h);
265*fae548d3Szrj h = iterative_hash_object (c->data_align, h);
266*fae548d3Szrj h = iterative_hash_object (c->ra_column, h);
267*fae548d3Szrj h = iterative_hash_object (c->augmentation_size, h);
268*fae548d3Szrj h = iterative_hash_object (c->personality, h);
269*fae548d3Szrj h = iterative_hash_object (c->cie_inf->u.cie.u.sec->output_section, h);
270*fae548d3Szrj h = iterative_hash_object (c->per_encoding, h);
271*fae548d3Szrj h = iterative_hash_object (c->lsda_encoding, h);
272*fae548d3Szrj h = iterative_hash_object (c->fde_encoding, h);
273*fae548d3Szrj h = iterative_hash_object (c->initial_insn_length, h);
274*fae548d3Szrj len = c->initial_insn_length;
275*fae548d3Szrj if (len > sizeof (c->initial_instructions))
276*fae548d3Szrj len = sizeof (c->initial_instructions);
277*fae548d3Szrj h = iterative_hash (c->initial_instructions, len, h);
278*fae548d3Szrj c->hash = h;
279*fae548d3Szrj return h;
280*fae548d3Szrj }
281*fae548d3Szrj
282*fae548d3Szrj /* Return the number of extra bytes that we'll be inserting into
283*fae548d3Szrj ENTRY's augmentation string. */
284*fae548d3Szrj
285*fae548d3Szrj static INLINE unsigned int
extra_augmentation_string_bytes(struct eh_cie_fde * entry)286*fae548d3Szrj extra_augmentation_string_bytes (struct eh_cie_fde *entry)
287*fae548d3Szrj {
288*fae548d3Szrj unsigned int size = 0;
289*fae548d3Szrj if (entry->cie)
290*fae548d3Szrj {
291*fae548d3Szrj if (entry->add_augmentation_size)
292*fae548d3Szrj size++;
293*fae548d3Szrj if (entry->u.cie.add_fde_encoding)
294*fae548d3Szrj size++;
295*fae548d3Szrj }
296*fae548d3Szrj return size;
297*fae548d3Szrj }
298*fae548d3Szrj
299*fae548d3Szrj /* Likewise ENTRY's augmentation data. */
300*fae548d3Szrj
301*fae548d3Szrj static INLINE unsigned int
extra_augmentation_data_bytes(struct eh_cie_fde * entry)302*fae548d3Szrj extra_augmentation_data_bytes (struct eh_cie_fde *entry)
303*fae548d3Szrj {
304*fae548d3Szrj unsigned int size = 0;
305*fae548d3Szrj if (entry->add_augmentation_size)
306*fae548d3Szrj size++;
307*fae548d3Szrj if (entry->cie && entry->u.cie.add_fde_encoding)
308*fae548d3Szrj size++;
309*fae548d3Szrj return size;
310*fae548d3Szrj }
311*fae548d3Szrj
312*fae548d3Szrj /* Return the size that ENTRY will have in the output. */
313*fae548d3Szrj
314*fae548d3Szrj static unsigned int
size_of_output_cie_fde(struct eh_cie_fde * entry)315*fae548d3Szrj size_of_output_cie_fde (struct eh_cie_fde *entry)
316*fae548d3Szrj {
317*fae548d3Szrj if (entry->removed)
318*fae548d3Szrj return 0;
319*fae548d3Szrj if (entry->size == 4)
320*fae548d3Szrj return 4;
321*fae548d3Szrj return (entry->size
322*fae548d3Szrj + extra_augmentation_string_bytes (entry)
323*fae548d3Szrj + extra_augmentation_data_bytes (entry));
324*fae548d3Szrj }
325*fae548d3Szrj
326*fae548d3Szrj /* Return the offset of the FDE or CIE after ENT. */
327*fae548d3Szrj
328*fae548d3Szrj static unsigned int
next_cie_fde_offset(const struct eh_cie_fde * ent,const struct eh_cie_fde * last,const asection * sec)329*fae548d3Szrj next_cie_fde_offset (const struct eh_cie_fde *ent,
330*fae548d3Szrj const struct eh_cie_fde *last,
331*fae548d3Szrj const asection *sec)
332*fae548d3Szrj {
333*fae548d3Szrj while (++ent < last)
334*fae548d3Szrj {
335*fae548d3Szrj if (!ent->removed)
336*fae548d3Szrj return ent->new_offset;
337*fae548d3Szrj }
338*fae548d3Szrj return sec->size;
339*fae548d3Szrj }
340*fae548d3Szrj
341*fae548d3Szrj /* Assume that the bytes between *ITER and END are CFA instructions.
342*fae548d3Szrj Try to move *ITER past the first instruction and return true on
343*fae548d3Szrj success. ENCODED_PTR_WIDTH gives the width of pointer entries. */
344*fae548d3Szrj
345*fae548d3Szrj static bfd_boolean
skip_cfa_op(bfd_byte ** iter,bfd_byte * end,unsigned int encoded_ptr_width)346*fae548d3Szrj skip_cfa_op (bfd_byte **iter, bfd_byte *end, unsigned int encoded_ptr_width)
347*fae548d3Szrj {
348*fae548d3Szrj bfd_byte op;
349*fae548d3Szrj bfd_vma length;
350*fae548d3Szrj
351*fae548d3Szrj if (!read_byte (iter, end, &op))
352*fae548d3Szrj return FALSE;
353*fae548d3Szrj
354*fae548d3Szrj switch (op & 0xc0 ? op & 0xc0 : op)
355*fae548d3Szrj {
356*fae548d3Szrj case DW_CFA_nop:
357*fae548d3Szrj case DW_CFA_advance_loc:
358*fae548d3Szrj case DW_CFA_restore:
359*fae548d3Szrj case DW_CFA_remember_state:
360*fae548d3Szrj case DW_CFA_restore_state:
361*fae548d3Szrj case DW_CFA_GNU_window_save:
362*fae548d3Szrj /* No arguments. */
363*fae548d3Szrj return TRUE;
364*fae548d3Szrj
365*fae548d3Szrj case DW_CFA_offset:
366*fae548d3Szrj case DW_CFA_restore_extended:
367*fae548d3Szrj case DW_CFA_undefined:
368*fae548d3Szrj case DW_CFA_same_value:
369*fae548d3Szrj case DW_CFA_def_cfa_register:
370*fae548d3Szrj case DW_CFA_def_cfa_offset:
371*fae548d3Szrj case DW_CFA_def_cfa_offset_sf:
372*fae548d3Szrj case DW_CFA_GNU_args_size:
373*fae548d3Szrj /* One leb128 argument. */
374*fae548d3Szrj return skip_leb128 (iter, end);
375*fae548d3Szrj
376*fae548d3Szrj case DW_CFA_val_offset:
377*fae548d3Szrj case DW_CFA_val_offset_sf:
378*fae548d3Szrj case DW_CFA_offset_extended:
379*fae548d3Szrj case DW_CFA_register:
380*fae548d3Szrj case DW_CFA_def_cfa:
381*fae548d3Szrj case DW_CFA_offset_extended_sf:
382*fae548d3Szrj case DW_CFA_GNU_negative_offset_extended:
383*fae548d3Szrj case DW_CFA_def_cfa_sf:
384*fae548d3Szrj /* Two leb128 arguments. */
385*fae548d3Szrj return (skip_leb128 (iter, end)
386*fae548d3Szrj && skip_leb128 (iter, end));
387*fae548d3Szrj
388*fae548d3Szrj case DW_CFA_def_cfa_expression:
389*fae548d3Szrj /* A variable-length argument. */
390*fae548d3Szrj return (read_uleb128 (iter, end, &length)
391*fae548d3Szrj && skip_bytes (iter, end, length));
392*fae548d3Szrj
393*fae548d3Szrj case DW_CFA_expression:
394*fae548d3Szrj case DW_CFA_val_expression:
395*fae548d3Szrj /* A leb128 followed by a variable-length argument. */
396*fae548d3Szrj return (skip_leb128 (iter, end)
397*fae548d3Szrj && read_uleb128 (iter, end, &length)
398*fae548d3Szrj && skip_bytes (iter, end, length));
399*fae548d3Szrj
400*fae548d3Szrj case DW_CFA_set_loc:
401*fae548d3Szrj return skip_bytes (iter, end, encoded_ptr_width);
402*fae548d3Szrj
403*fae548d3Szrj case DW_CFA_advance_loc1:
404*fae548d3Szrj return skip_bytes (iter, end, 1);
405*fae548d3Szrj
406*fae548d3Szrj case DW_CFA_advance_loc2:
407*fae548d3Szrj return skip_bytes (iter, end, 2);
408*fae548d3Szrj
409*fae548d3Szrj case DW_CFA_advance_loc4:
410*fae548d3Szrj return skip_bytes (iter, end, 4);
411*fae548d3Szrj
412*fae548d3Szrj case DW_CFA_MIPS_advance_loc8:
413*fae548d3Szrj return skip_bytes (iter, end, 8);
414*fae548d3Szrj
415*fae548d3Szrj default:
416*fae548d3Szrj return FALSE;
417*fae548d3Szrj }
418*fae548d3Szrj }
419*fae548d3Szrj
420*fae548d3Szrj /* Try to interpret the bytes between BUF and END as CFA instructions.
421*fae548d3Szrj If every byte makes sense, return a pointer to the first DW_CFA_nop
422*fae548d3Szrj padding byte, or END if there is no padding. Return null otherwise.
423*fae548d3Szrj ENCODED_PTR_WIDTH is as for skip_cfa_op. */
424*fae548d3Szrj
425*fae548d3Szrj static bfd_byte *
skip_non_nops(bfd_byte * buf,bfd_byte * end,unsigned int encoded_ptr_width,unsigned int * set_loc_count)426*fae548d3Szrj skip_non_nops (bfd_byte *buf, bfd_byte *end, unsigned int encoded_ptr_width,
427*fae548d3Szrj unsigned int *set_loc_count)
428*fae548d3Szrj {
429*fae548d3Szrj bfd_byte *last;
430*fae548d3Szrj
431*fae548d3Szrj last = buf;
432*fae548d3Szrj while (buf < end)
433*fae548d3Szrj if (*buf == DW_CFA_nop)
434*fae548d3Szrj buf++;
435*fae548d3Szrj else
436*fae548d3Szrj {
437*fae548d3Szrj if (*buf == DW_CFA_set_loc)
438*fae548d3Szrj ++*set_loc_count;
439*fae548d3Szrj if (!skip_cfa_op (&buf, end, encoded_ptr_width))
440*fae548d3Szrj return 0;
441*fae548d3Szrj last = buf;
442*fae548d3Szrj }
443*fae548d3Szrj return last;
444*fae548d3Szrj }
445*fae548d3Szrj
446*fae548d3Szrj /* Convert absolute encoding ENCODING into PC-relative form.
447*fae548d3Szrj SIZE is the size of a pointer. */
448*fae548d3Szrj
449*fae548d3Szrj static unsigned char
make_pc_relative(unsigned char encoding,unsigned int ptr_size)450*fae548d3Szrj make_pc_relative (unsigned char encoding, unsigned int ptr_size)
451*fae548d3Szrj {
452*fae548d3Szrj if ((encoding & 0x7f) == DW_EH_PE_absptr)
453*fae548d3Szrj switch (ptr_size)
454*fae548d3Szrj {
455*fae548d3Szrj case 2:
456*fae548d3Szrj encoding |= DW_EH_PE_sdata2;
457*fae548d3Szrj break;
458*fae548d3Szrj case 4:
459*fae548d3Szrj encoding |= DW_EH_PE_sdata4;
460*fae548d3Szrj break;
461*fae548d3Szrj case 8:
462*fae548d3Szrj encoding |= DW_EH_PE_sdata8;
463*fae548d3Szrj break;
464*fae548d3Szrj }
465*fae548d3Szrj return encoding | DW_EH_PE_pcrel;
466*fae548d3Szrj }
467*fae548d3Szrj
468*fae548d3Szrj /* Examine each .eh_frame_entry section and discard those
469*fae548d3Szrj those that are marked SEC_EXCLUDE. */
470*fae548d3Szrj
471*fae548d3Szrj static void
bfd_elf_discard_eh_frame_entry(struct eh_frame_hdr_info * hdr_info)472*fae548d3Szrj bfd_elf_discard_eh_frame_entry (struct eh_frame_hdr_info *hdr_info)
473*fae548d3Szrj {
474*fae548d3Szrj unsigned int i;
475*fae548d3Szrj for (i = 0; i < hdr_info->array_count; i++)
476*fae548d3Szrj {
477*fae548d3Szrj if (hdr_info->u.compact.entries[i]->flags & SEC_EXCLUDE)
478*fae548d3Szrj {
479*fae548d3Szrj unsigned int j;
480*fae548d3Szrj for (j = i + 1; j < hdr_info->array_count; j++)
481*fae548d3Szrj hdr_info->u.compact.entries[j-1] = hdr_info->u.compact.entries[j];
482*fae548d3Szrj
483*fae548d3Szrj hdr_info->array_count--;
484*fae548d3Szrj hdr_info->u.compact.entries[hdr_info->array_count] = NULL;
485*fae548d3Szrj i--;
486*fae548d3Szrj }
487*fae548d3Szrj }
488*fae548d3Szrj }
489*fae548d3Szrj
490*fae548d3Szrj /* Add a .eh_frame_entry section. */
491*fae548d3Szrj
492*fae548d3Szrj static void
bfd_elf_record_eh_frame_entry(struct eh_frame_hdr_info * hdr_info,asection * sec)493*fae548d3Szrj bfd_elf_record_eh_frame_entry (struct eh_frame_hdr_info *hdr_info,
494*fae548d3Szrj asection *sec)
495*fae548d3Szrj {
496*fae548d3Szrj if (hdr_info->array_count == hdr_info->u.compact.allocated_entries)
497*fae548d3Szrj {
498*fae548d3Szrj if (hdr_info->u.compact.allocated_entries == 0)
499*fae548d3Szrj {
500*fae548d3Szrj hdr_info->frame_hdr_is_compact = TRUE;
501*fae548d3Szrj hdr_info->u.compact.allocated_entries = 2;
502*fae548d3Szrj hdr_info->u.compact.entries =
503*fae548d3Szrj bfd_malloc (hdr_info->u.compact.allocated_entries
504*fae548d3Szrj * sizeof (hdr_info->u.compact.entries[0]));
505*fae548d3Szrj }
506*fae548d3Szrj else
507*fae548d3Szrj {
508*fae548d3Szrj hdr_info->u.compact.allocated_entries *= 2;
509*fae548d3Szrj hdr_info->u.compact.entries =
510*fae548d3Szrj bfd_realloc (hdr_info->u.compact.entries,
511*fae548d3Szrj hdr_info->u.compact.allocated_entries
512*fae548d3Szrj * sizeof (hdr_info->u.compact.entries[0]));
513*fae548d3Szrj }
514*fae548d3Szrj
515*fae548d3Szrj BFD_ASSERT (hdr_info->u.compact.entries);
516*fae548d3Szrj }
517*fae548d3Szrj
518*fae548d3Szrj hdr_info->u.compact.entries[hdr_info->array_count++] = sec;
519*fae548d3Szrj }
520*fae548d3Szrj
521*fae548d3Szrj /* Parse a .eh_frame_entry section. Figure out which text section it
522*fae548d3Szrj references. */
523*fae548d3Szrj
524*fae548d3Szrj bfd_boolean
_bfd_elf_parse_eh_frame_entry(struct bfd_link_info * info,asection * sec,struct elf_reloc_cookie * cookie)525*fae548d3Szrj _bfd_elf_parse_eh_frame_entry (struct bfd_link_info *info,
526*fae548d3Szrj asection *sec, struct elf_reloc_cookie *cookie)
527*fae548d3Szrj {
528*fae548d3Szrj struct elf_link_hash_table *htab;
529*fae548d3Szrj struct eh_frame_hdr_info *hdr_info;
530*fae548d3Szrj unsigned long r_symndx;
531*fae548d3Szrj asection *text_sec;
532*fae548d3Szrj
533*fae548d3Szrj htab = elf_hash_table (info);
534*fae548d3Szrj hdr_info = &htab->eh_info;
535*fae548d3Szrj
536*fae548d3Szrj if (sec->size == 0
537*fae548d3Szrj || sec->sec_info_type != SEC_INFO_TYPE_NONE)
538*fae548d3Szrj {
539*fae548d3Szrj return TRUE;
540*fae548d3Szrj }
541*fae548d3Szrj
542*fae548d3Szrj if (sec->output_section && bfd_is_abs_section (sec->output_section))
543*fae548d3Szrj {
544*fae548d3Szrj /* At least one of the sections is being discarded from the
545*fae548d3Szrj link, so we should just ignore them. */
546*fae548d3Szrj return TRUE;
547*fae548d3Szrj }
548*fae548d3Szrj
549*fae548d3Szrj if (cookie->rel == cookie->relend)
550*fae548d3Szrj return FALSE;
551*fae548d3Szrj
552*fae548d3Szrj /* The first relocation is the function start. */
553*fae548d3Szrj r_symndx = cookie->rel->r_info >> cookie->r_sym_shift;
554*fae548d3Szrj if (r_symndx == STN_UNDEF)
555*fae548d3Szrj return FALSE;
556*fae548d3Szrj
557*fae548d3Szrj text_sec = _bfd_elf_section_for_symbol (cookie, r_symndx, FALSE);
558*fae548d3Szrj
559*fae548d3Szrj if (text_sec == NULL)
560*fae548d3Szrj return FALSE;
561*fae548d3Szrj
562*fae548d3Szrj elf_section_eh_frame_entry (text_sec) = sec;
563*fae548d3Szrj if (text_sec->output_section
564*fae548d3Szrj && bfd_is_abs_section (text_sec->output_section))
565*fae548d3Szrj sec->flags |= SEC_EXCLUDE;
566*fae548d3Szrj
567*fae548d3Szrj sec->sec_info_type = SEC_INFO_TYPE_EH_FRAME_ENTRY;
568*fae548d3Szrj elf_section_data (sec)->sec_info = text_sec;
569*fae548d3Szrj bfd_elf_record_eh_frame_entry (hdr_info, sec);
570*fae548d3Szrj return TRUE;
571*fae548d3Szrj }
572*fae548d3Szrj
573*fae548d3Szrj /* Try to parse .eh_frame section SEC, which belongs to ABFD. Store the
574*fae548d3Szrj information in the section's sec_info field on success. COOKIE
575*fae548d3Szrj describes the relocations in SEC. */
576*fae548d3Szrj
577*fae548d3Szrj void
_bfd_elf_parse_eh_frame(bfd * abfd,struct bfd_link_info * info,asection * sec,struct elf_reloc_cookie * cookie)578*fae548d3Szrj _bfd_elf_parse_eh_frame (bfd *abfd, struct bfd_link_info *info,
579*fae548d3Szrj asection *sec, struct elf_reloc_cookie *cookie)
580*fae548d3Szrj {
581*fae548d3Szrj #define REQUIRE(COND) \
582*fae548d3Szrj do \
583*fae548d3Szrj if (!(COND)) \
584*fae548d3Szrj goto free_no_table; \
585*fae548d3Szrj while (0)
586*fae548d3Szrj
587*fae548d3Szrj bfd_byte *ehbuf = NULL, *buf, *end;
588*fae548d3Szrj bfd_byte *last_fde;
589*fae548d3Szrj struct eh_cie_fde *this_inf;
590*fae548d3Szrj unsigned int hdr_length, hdr_id;
591*fae548d3Szrj unsigned int cie_count;
592*fae548d3Szrj struct cie *cie, *local_cies = NULL;
593*fae548d3Szrj struct elf_link_hash_table *htab;
594*fae548d3Szrj struct eh_frame_hdr_info *hdr_info;
595*fae548d3Szrj struct eh_frame_sec_info *sec_info = NULL;
596*fae548d3Szrj unsigned int ptr_size;
597*fae548d3Szrj unsigned int num_cies;
598*fae548d3Szrj unsigned int num_entries;
599*fae548d3Szrj elf_gc_mark_hook_fn gc_mark_hook;
600*fae548d3Szrj
601*fae548d3Szrj htab = elf_hash_table (info);
602*fae548d3Szrj hdr_info = &htab->eh_info;
603*fae548d3Szrj
604*fae548d3Szrj if (sec->size == 0
605*fae548d3Szrj || sec->sec_info_type != SEC_INFO_TYPE_NONE)
606*fae548d3Szrj {
607*fae548d3Szrj /* This file does not contain .eh_frame information. */
608*fae548d3Szrj return;
609*fae548d3Szrj }
610*fae548d3Szrj
611*fae548d3Szrj if (bfd_is_abs_section (sec->output_section))
612*fae548d3Szrj {
613*fae548d3Szrj /* At least one of the sections is being discarded from the
614*fae548d3Szrj link, so we should just ignore them. */
615*fae548d3Szrj return;
616*fae548d3Szrj }
617*fae548d3Szrj
618*fae548d3Szrj /* Read the frame unwind information from abfd. */
619*fae548d3Szrj
620*fae548d3Szrj REQUIRE (bfd_malloc_and_get_section (abfd, sec, &ehbuf));
621*fae548d3Szrj
622*fae548d3Szrj /* If .eh_frame section size doesn't fit into int, we cannot handle
623*fae548d3Szrj it (it would need to use 64-bit .eh_frame format anyway). */
624*fae548d3Szrj REQUIRE (sec->size == (unsigned int) sec->size);
625*fae548d3Szrj
626*fae548d3Szrj ptr_size = (get_elf_backend_data (abfd)
627*fae548d3Szrj ->elf_backend_eh_frame_address_size (abfd, sec));
628*fae548d3Szrj REQUIRE (ptr_size != 0);
629*fae548d3Szrj
630*fae548d3Szrj /* Go through the section contents and work out how many FDEs and
631*fae548d3Szrj CIEs there are. */
632*fae548d3Szrj buf = ehbuf;
633*fae548d3Szrj end = ehbuf + sec->size;
634*fae548d3Szrj num_cies = 0;
635*fae548d3Szrj num_entries = 0;
636*fae548d3Szrj while (buf != end)
637*fae548d3Szrj {
638*fae548d3Szrj num_entries++;
639*fae548d3Szrj
640*fae548d3Szrj /* Read the length of the entry. */
641*fae548d3Szrj REQUIRE (skip_bytes (&buf, end, 4));
642*fae548d3Szrj hdr_length = bfd_get_32 (abfd, buf - 4);
643*fae548d3Szrj
644*fae548d3Szrj /* 64-bit .eh_frame is not supported. */
645*fae548d3Szrj REQUIRE (hdr_length != 0xffffffff);
646*fae548d3Szrj if (hdr_length == 0)
647*fae548d3Szrj break;
648*fae548d3Szrj
649*fae548d3Szrj REQUIRE (skip_bytes (&buf, end, 4));
650*fae548d3Szrj hdr_id = bfd_get_32 (abfd, buf - 4);
651*fae548d3Szrj if (hdr_id == 0)
652*fae548d3Szrj num_cies++;
653*fae548d3Szrj
654*fae548d3Szrj REQUIRE (skip_bytes (&buf, end, hdr_length - 4));
655*fae548d3Szrj }
656*fae548d3Szrj
657*fae548d3Szrj sec_info = (struct eh_frame_sec_info *)
658*fae548d3Szrj bfd_zmalloc (sizeof (struct eh_frame_sec_info)
659*fae548d3Szrj + (num_entries - 1) * sizeof (struct eh_cie_fde));
660*fae548d3Szrj REQUIRE (sec_info);
661*fae548d3Szrj
662*fae548d3Szrj /* We need to have a "struct cie" for each CIE in this section. */
663*fae548d3Szrj if (num_cies)
664*fae548d3Szrj {
665*fae548d3Szrj local_cies = (struct cie *) bfd_zmalloc (num_cies * sizeof (*local_cies));
666*fae548d3Szrj REQUIRE (local_cies);
667*fae548d3Szrj }
668*fae548d3Szrj
669*fae548d3Szrj /* FIXME: octets_per_byte. */
670*fae548d3Szrj #define ENSURE_NO_RELOCS(buf) \
671*fae548d3Szrj while (cookie->rel < cookie->relend \
672*fae548d3Szrj && (cookie->rel->r_offset \
673*fae548d3Szrj < (bfd_size_type) ((buf) - ehbuf))) \
674*fae548d3Szrj { \
675*fae548d3Szrj REQUIRE (cookie->rel->r_info == 0); \
676*fae548d3Szrj cookie->rel++; \
677*fae548d3Szrj }
678*fae548d3Szrj
679*fae548d3Szrj /* FIXME: octets_per_byte. */
680*fae548d3Szrj #define SKIP_RELOCS(buf) \
681*fae548d3Szrj while (cookie->rel < cookie->relend \
682*fae548d3Szrj && (cookie->rel->r_offset \
683*fae548d3Szrj < (bfd_size_type) ((buf) - ehbuf))) \
684*fae548d3Szrj cookie->rel++
685*fae548d3Szrj
686*fae548d3Szrj /* FIXME: octets_per_byte. */
687*fae548d3Szrj #define GET_RELOC(buf) \
688*fae548d3Szrj ((cookie->rel < cookie->relend \
689*fae548d3Szrj && (cookie->rel->r_offset \
690*fae548d3Szrj == (bfd_size_type) ((buf) - ehbuf))) \
691*fae548d3Szrj ? cookie->rel : NULL)
692*fae548d3Szrj
693*fae548d3Szrj buf = ehbuf;
694*fae548d3Szrj cie_count = 0;
695*fae548d3Szrj gc_mark_hook = get_elf_backend_data (abfd)->gc_mark_hook;
696*fae548d3Szrj while ((bfd_size_type) (buf - ehbuf) != sec->size)
697*fae548d3Szrj {
698*fae548d3Szrj char *aug;
699*fae548d3Szrj bfd_byte *start, *insns, *insns_end;
700*fae548d3Szrj bfd_size_type length;
701*fae548d3Szrj unsigned int set_loc_count;
702*fae548d3Szrj
703*fae548d3Szrj this_inf = sec_info->entry + sec_info->count;
704*fae548d3Szrj last_fde = buf;
705*fae548d3Szrj
706*fae548d3Szrj /* Read the length of the entry. */
707*fae548d3Szrj REQUIRE (skip_bytes (&buf, ehbuf + sec->size, 4));
708*fae548d3Szrj hdr_length = bfd_get_32 (abfd, buf - 4);
709*fae548d3Szrj
710*fae548d3Szrj /* The CIE/FDE must be fully contained in this input section. */
711*fae548d3Szrj REQUIRE ((bfd_size_type) (buf - ehbuf) + hdr_length <= sec->size);
712*fae548d3Szrj end = buf + hdr_length;
713*fae548d3Szrj
714*fae548d3Szrj this_inf->offset = last_fde - ehbuf;
715*fae548d3Szrj this_inf->size = 4 + hdr_length;
716*fae548d3Szrj this_inf->reloc_index = cookie->rel - cookie->rels;
717*fae548d3Szrj
718*fae548d3Szrj if (hdr_length == 0)
719*fae548d3Szrj {
720*fae548d3Szrj /* A zero-length CIE should only be found at the end of
721*fae548d3Szrj the section, but allow multiple terminators. */
722*fae548d3Szrj while (skip_bytes (&buf, ehbuf + sec->size, 4))
723*fae548d3Szrj REQUIRE (bfd_get_32 (abfd, buf - 4) == 0);
724*fae548d3Szrj REQUIRE ((bfd_size_type) (buf - ehbuf) == sec->size);
725*fae548d3Szrj ENSURE_NO_RELOCS (buf);
726*fae548d3Szrj sec_info->count++;
727*fae548d3Szrj break;
728*fae548d3Szrj }
729*fae548d3Szrj
730*fae548d3Szrj REQUIRE (skip_bytes (&buf, end, 4));
731*fae548d3Szrj hdr_id = bfd_get_32 (abfd, buf - 4);
732*fae548d3Szrj
733*fae548d3Szrj if (hdr_id == 0)
734*fae548d3Szrj {
735*fae548d3Szrj unsigned int initial_insn_length;
736*fae548d3Szrj
737*fae548d3Szrj /* CIE */
738*fae548d3Szrj this_inf->cie = 1;
739*fae548d3Szrj
740*fae548d3Szrj /* Point CIE to one of the section-local cie structures. */
741*fae548d3Szrj cie = local_cies + cie_count++;
742*fae548d3Szrj
743*fae548d3Szrj cie->cie_inf = this_inf;
744*fae548d3Szrj cie->length = hdr_length;
745*fae548d3Szrj start = buf;
746*fae548d3Szrj REQUIRE (read_byte (&buf, end, &cie->version));
747*fae548d3Szrj
748*fae548d3Szrj /* Cannot handle unknown versions. */
749*fae548d3Szrj REQUIRE (cie->version == 1
750*fae548d3Szrj || cie->version == 3
751*fae548d3Szrj || cie->version == 4);
752*fae548d3Szrj REQUIRE (strlen ((char *) buf) < sizeof (cie->augmentation));
753*fae548d3Szrj
754*fae548d3Szrj strcpy (cie->augmentation, (char *) buf);
755*fae548d3Szrj buf = (bfd_byte *) strchr ((char *) buf, '\0') + 1;
756*fae548d3Szrj this_inf->u.cie.aug_str_len = buf - start - 1;
757*fae548d3Szrj ENSURE_NO_RELOCS (buf);
758*fae548d3Szrj if (buf[0] == 'e' && buf[1] == 'h')
759*fae548d3Szrj {
760*fae548d3Szrj /* GCC < 3.0 .eh_frame CIE */
761*fae548d3Szrj /* We cannot merge "eh" CIEs because __EXCEPTION_TABLE__
762*fae548d3Szrj is private to each CIE, so we don't need it for anything.
763*fae548d3Szrj Just skip it. */
764*fae548d3Szrj REQUIRE (skip_bytes (&buf, end, ptr_size));
765*fae548d3Szrj SKIP_RELOCS (buf);
766*fae548d3Szrj }
767*fae548d3Szrj if (cie->version >= 4)
768*fae548d3Szrj {
769*fae548d3Szrj REQUIRE (buf + 1 < end);
770*fae548d3Szrj REQUIRE (buf[0] == ptr_size);
771*fae548d3Szrj REQUIRE (buf[1] == 0);
772*fae548d3Szrj buf += 2;
773*fae548d3Szrj }
774*fae548d3Szrj REQUIRE (read_uleb128 (&buf, end, &cie->code_align));
775*fae548d3Szrj REQUIRE (read_sleb128 (&buf, end, &cie->data_align));
776*fae548d3Szrj if (cie->version == 1)
777*fae548d3Szrj {
778*fae548d3Szrj REQUIRE (buf < end);
779*fae548d3Szrj cie->ra_column = *buf++;
780*fae548d3Szrj }
781*fae548d3Szrj else
782*fae548d3Szrj REQUIRE (read_uleb128 (&buf, end, &cie->ra_column));
783*fae548d3Szrj ENSURE_NO_RELOCS (buf);
784*fae548d3Szrj cie->lsda_encoding = DW_EH_PE_omit;
785*fae548d3Szrj cie->fde_encoding = DW_EH_PE_omit;
786*fae548d3Szrj cie->per_encoding = DW_EH_PE_omit;
787*fae548d3Szrj aug = cie->augmentation;
788*fae548d3Szrj if (aug[0] != 'e' || aug[1] != 'h')
789*fae548d3Szrj {
790*fae548d3Szrj if (*aug == 'z')
791*fae548d3Szrj {
792*fae548d3Szrj aug++;
793*fae548d3Szrj REQUIRE (read_uleb128 (&buf, end, &cie->augmentation_size));
794*fae548d3Szrj ENSURE_NO_RELOCS (buf);
795*fae548d3Szrj }
796*fae548d3Szrj
797*fae548d3Szrj while (*aug != '\0')
798*fae548d3Szrj switch (*aug++)
799*fae548d3Szrj {
800*fae548d3Szrj case 'B':
801*fae548d3Szrj break;
802*fae548d3Szrj case 'L':
803*fae548d3Szrj REQUIRE (read_byte (&buf, end, &cie->lsda_encoding));
804*fae548d3Szrj ENSURE_NO_RELOCS (buf);
805*fae548d3Szrj REQUIRE (get_DW_EH_PE_width (cie->lsda_encoding, ptr_size));
806*fae548d3Szrj break;
807*fae548d3Szrj case 'R':
808*fae548d3Szrj REQUIRE (read_byte (&buf, end, &cie->fde_encoding));
809*fae548d3Szrj ENSURE_NO_RELOCS (buf);
810*fae548d3Szrj REQUIRE (get_DW_EH_PE_width (cie->fde_encoding, ptr_size));
811*fae548d3Szrj break;
812*fae548d3Szrj case 'S':
813*fae548d3Szrj break;
814*fae548d3Szrj case 'P':
815*fae548d3Szrj {
816*fae548d3Szrj int per_width;
817*fae548d3Szrj
818*fae548d3Szrj REQUIRE (read_byte (&buf, end, &cie->per_encoding));
819*fae548d3Szrj per_width = get_DW_EH_PE_width (cie->per_encoding,
820*fae548d3Szrj ptr_size);
821*fae548d3Szrj REQUIRE (per_width);
822*fae548d3Szrj if ((cie->per_encoding & 0x70) == DW_EH_PE_aligned)
823*fae548d3Szrj {
824*fae548d3Szrj length = -(buf - ehbuf) & (per_width - 1);
825*fae548d3Szrj REQUIRE (skip_bytes (&buf, end, length));
826*fae548d3Szrj if (per_width == 8)
827*fae548d3Szrj this_inf->u.cie.per_encoding_aligned8 = 1;
828*fae548d3Szrj }
829*fae548d3Szrj this_inf->u.cie.personality_offset = buf - start;
830*fae548d3Szrj ENSURE_NO_RELOCS (buf);
831*fae548d3Szrj /* Ensure we have a reloc here. */
832*fae548d3Szrj REQUIRE (GET_RELOC (buf));
833*fae548d3Szrj cie->personality.reloc_index
834*fae548d3Szrj = cookie->rel - cookie->rels;
835*fae548d3Szrj /* Cope with MIPS-style composite relocations. */
836*fae548d3Szrj do
837*fae548d3Szrj cookie->rel++;
838*fae548d3Szrj while (GET_RELOC (buf) != NULL);
839*fae548d3Szrj REQUIRE (skip_bytes (&buf, end, per_width));
840*fae548d3Szrj }
841*fae548d3Szrj break;
842*fae548d3Szrj default:
843*fae548d3Szrj /* Unrecognized augmentation. Better bail out. */
844*fae548d3Szrj goto free_no_table;
845*fae548d3Szrj }
846*fae548d3Szrj }
847*fae548d3Szrj this_inf->u.cie.aug_data_len
848*fae548d3Szrj = buf - start - 1 - this_inf->u.cie.aug_str_len;
849*fae548d3Szrj
850*fae548d3Szrj /* For shared libraries, try to get rid of as many RELATIVE relocs
851*fae548d3Szrj as possible. */
852*fae548d3Szrj if (bfd_link_pic (info)
853*fae548d3Szrj && (get_elf_backend_data (abfd)
854*fae548d3Szrj ->elf_backend_can_make_relative_eh_frame
855*fae548d3Szrj (abfd, info, sec)))
856*fae548d3Szrj {
857*fae548d3Szrj if ((cie->fde_encoding & 0x70) == DW_EH_PE_absptr)
858*fae548d3Szrj this_inf->make_relative = 1;
859*fae548d3Szrj /* If the CIE doesn't already have an 'R' entry, it's fairly
860*fae548d3Szrj easy to add one, provided that there's no aligned data
861*fae548d3Szrj after the augmentation string. */
862*fae548d3Szrj else if (cie->fde_encoding == DW_EH_PE_omit
863*fae548d3Szrj && (cie->per_encoding & 0x70) != DW_EH_PE_aligned)
864*fae548d3Szrj {
865*fae548d3Szrj if (*cie->augmentation == 0)
866*fae548d3Szrj this_inf->add_augmentation_size = 1;
867*fae548d3Szrj this_inf->u.cie.add_fde_encoding = 1;
868*fae548d3Szrj this_inf->make_relative = 1;
869*fae548d3Szrj }
870*fae548d3Szrj
871*fae548d3Szrj if ((cie->lsda_encoding & 0x70) == DW_EH_PE_absptr)
872*fae548d3Szrj cie->can_make_lsda_relative = 1;
873*fae548d3Szrj }
874*fae548d3Szrj
875*fae548d3Szrj /* If FDE encoding was not specified, it defaults to
876*fae548d3Szrj DW_EH_absptr. */
877*fae548d3Szrj if (cie->fde_encoding == DW_EH_PE_omit)
878*fae548d3Szrj cie->fde_encoding = DW_EH_PE_absptr;
879*fae548d3Szrj
880*fae548d3Szrj initial_insn_length = end - buf;
881*fae548d3Szrj cie->initial_insn_length = initial_insn_length;
882*fae548d3Szrj memcpy (cie->initial_instructions, buf,
883*fae548d3Szrj initial_insn_length <= sizeof (cie->initial_instructions)
884*fae548d3Szrj ? initial_insn_length : sizeof (cie->initial_instructions));
885*fae548d3Szrj insns = buf;
886*fae548d3Szrj buf += initial_insn_length;
887*fae548d3Szrj ENSURE_NO_RELOCS (buf);
888*fae548d3Szrj
889*fae548d3Szrj if (!bfd_link_relocatable (info))
890*fae548d3Szrj {
891*fae548d3Szrj /* Keep info for merging cies. */
892*fae548d3Szrj this_inf->u.cie.u.full_cie = cie;
893*fae548d3Szrj this_inf->u.cie.per_encoding_relative
894*fae548d3Szrj = (cie->per_encoding & 0x70) == DW_EH_PE_pcrel;
895*fae548d3Szrj }
896*fae548d3Szrj }
897*fae548d3Szrj else
898*fae548d3Szrj {
899*fae548d3Szrj /* Find the corresponding CIE. */
900*fae548d3Szrj unsigned int cie_offset = this_inf->offset + 4 - hdr_id;
901*fae548d3Szrj for (cie = local_cies; cie < local_cies + cie_count; cie++)
902*fae548d3Szrj if (cie_offset == cie->cie_inf->offset)
903*fae548d3Szrj break;
904*fae548d3Szrj
905*fae548d3Szrj /* Ensure this FDE references one of the CIEs in this input
906*fae548d3Szrj section. */
907*fae548d3Szrj REQUIRE (cie != local_cies + cie_count);
908*fae548d3Szrj this_inf->u.fde.cie_inf = cie->cie_inf;
909*fae548d3Szrj this_inf->make_relative = cie->cie_inf->make_relative;
910*fae548d3Szrj this_inf->add_augmentation_size
911*fae548d3Szrj = cie->cie_inf->add_augmentation_size;
912*fae548d3Szrj
913*fae548d3Szrj ENSURE_NO_RELOCS (buf);
914*fae548d3Szrj if ((sec->flags & SEC_LINKER_CREATED) == 0 || cookie->rels != NULL)
915*fae548d3Szrj {
916*fae548d3Szrj asection *rsec;
917*fae548d3Szrj
918*fae548d3Szrj REQUIRE (GET_RELOC (buf));
919*fae548d3Szrj
920*fae548d3Szrj /* Chain together the FDEs for each section. */
921*fae548d3Szrj rsec = _bfd_elf_gc_mark_rsec (info, sec, gc_mark_hook,
922*fae548d3Szrj cookie, NULL);
923*fae548d3Szrj /* RSEC will be NULL if FDE was cleared out as it was belonging to
924*fae548d3Szrj a discarded SHT_GROUP. */
925*fae548d3Szrj if (rsec)
926*fae548d3Szrj {
927*fae548d3Szrj REQUIRE (rsec->owner == abfd);
928*fae548d3Szrj this_inf->u.fde.next_for_section = elf_fde_list (rsec);
929*fae548d3Szrj elf_fde_list (rsec) = this_inf;
930*fae548d3Szrj }
931*fae548d3Szrj }
932*fae548d3Szrj
933*fae548d3Szrj /* Skip the initial location and address range. */
934*fae548d3Szrj start = buf;
935*fae548d3Szrj length = get_DW_EH_PE_width (cie->fde_encoding, ptr_size);
936*fae548d3Szrj REQUIRE (skip_bytes (&buf, end, 2 * length));
937*fae548d3Szrj
938*fae548d3Szrj SKIP_RELOCS (buf - length);
939*fae548d3Szrj if (!GET_RELOC (buf - length)
940*fae548d3Szrj && read_value (abfd, buf - length, length, FALSE) == 0)
941*fae548d3Szrj {
942*fae548d3Szrj (*info->callbacks->minfo)
943*fae548d3Szrj /* xgettext:c-format */
944*fae548d3Szrj (_("discarding zero address range FDE in %pB(%pA).\n"),
945*fae548d3Szrj abfd, sec);
946*fae548d3Szrj this_inf->u.fde.cie_inf = NULL;
947*fae548d3Szrj }
948*fae548d3Szrj
949*fae548d3Szrj /* Skip the augmentation size, if present. */
950*fae548d3Szrj if (cie->augmentation[0] == 'z')
951*fae548d3Szrj REQUIRE (read_uleb128 (&buf, end, &length));
952*fae548d3Szrj else
953*fae548d3Szrj length = 0;
954*fae548d3Szrj
955*fae548d3Szrj /* Of the supported augmentation characters above, only 'L'
956*fae548d3Szrj adds augmentation data to the FDE. This code would need to
957*fae548d3Szrj be adjusted if any future augmentations do the same thing. */
958*fae548d3Szrj if (cie->lsda_encoding != DW_EH_PE_omit)
959*fae548d3Szrj {
960*fae548d3Szrj SKIP_RELOCS (buf);
961*fae548d3Szrj if (cie->can_make_lsda_relative && GET_RELOC (buf))
962*fae548d3Szrj cie->cie_inf->u.cie.make_lsda_relative = 1;
963*fae548d3Szrj this_inf->lsda_offset = buf - start;
964*fae548d3Szrj /* If there's no 'z' augmentation, we don't know where the
965*fae548d3Szrj CFA insns begin. Assume no padding. */
966*fae548d3Szrj if (cie->augmentation[0] != 'z')
967*fae548d3Szrj length = end - buf;
968*fae548d3Szrj }
969*fae548d3Szrj
970*fae548d3Szrj /* Skip over the augmentation data. */
971*fae548d3Szrj REQUIRE (skip_bytes (&buf, end, length));
972*fae548d3Szrj insns = buf;
973*fae548d3Szrj
974*fae548d3Szrj buf = last_fde + 4 + hdr_length;
975*fae548d3Szrj
976*fae548d3Szrj /* For NULL RSEC (cleared FDE belonging to a discarded section)
977*fae548d3Szrj the relocations are commonly cleared. We do not sanity check if
978*fae548d3Szrj all these relocations are cleared as (1) relocations to
979*fae548d3Szrj .gcc_except_table will remain uncleared (they will get dropped
980*fae548d3Szrj with the drop of this unused FDE) and (2) BFD already safely drops
981*fae548d3Szrj relocations of any type to .eh_frame by
982*fae548d3Szrj elf_section_ignore_discarded_relocs.
983*fae548d3Szrj TODO: The .gcc_except_table entries should be also filtered as
984*fae548d3Szrj .eh_frame entries; or GCC could rather use COMDAT for them. */
985*fae548d3Szrj SKIP_RELOCS (buf);
986*fae548d3Szrj }
987*fae548d3Szrj
988*fae548d3Szrj /* Try to interpret the CFA instructions and find the first
989*fae548d3Szrj padding nop. Shrink this_inf's size so that it doesn't
990*fae548d3Szrj include the padding. */
991*fae548d3Szrj length = get_DW_EH_PE_width (cie->fde_encoding, ptr_size);
992*fae548d3Szrj set_loc_count = 0;
993*fae548d3Szrj insns_end = skip_non_nops (insns, end, length, &set_loc_count);
994*fae548d3Szrj /* If we don't understand the CFA instructions, we can't know
995*fae548d3Szrj what needs to be adjusted there. */
996*fae548d3Szrj if (insns_end == NULL
997*fae548d3Szrj /* For the time being we don't support DW_CFA_set_loc in
998*fae548d3Szrj CIE instructions. */
999*fae548d3Szrj || (set_loc_count && this_inf->cie))
1000*fae548d3Szrj goto free_no_table;
1001*fae548d3Szrj this_inf->size -= end - insns_end;
1002*fae548d3Szrj if (insns_end != end && this_inf->cie)
1003*fae548d3Szrj {
1004*fae548d3Szrj cie->initial_insn_length -= end - insns_end;
1005*fae548d3Szrj cie->length -= end - insns_end;
1006*fae548d3Szrj }
1007*fae548d3Szrj if (set_loc_count
1008*fae548d3Szrj && ((cie->fde_encoding & 0x70) == DW_EH_PE_pcrel
1009*fae548d3Szrj || this_inf->make_relative))
1010*fae548d3Szrj {
1011*fae548d3Szrj unsigned int cnt;
1012*fae548d3Szrj bfd_byte *p;
1013*fae548d3Szrj
1014*fae548d3Szrj this_inf->set_loc = (unsigned int *)
1015*fae548d3Szrj bfd_malloc ((set_loc_count + 1) * sizeof (unsigned int));
1016*fae548d3Szrj REQUIRE (this_inf->set_loc);
1017*fae548d3Szrj this_inf->set_loc[0] = set_loc_count;
1018*fae548d3Szrj p = insns;
1019*fae548d3Szrj cnt = 0;
1020*fae548d3Szrj while (p < end)
1021*fae548d3Szrj {
1022*fae548d3Szrj if (*p == DW_CFA_set_loc)
1023*fae548d3Szrj this_inf->set_loc[++cnt] = p + 1 - start;
1024*fae548d3Szrj REQUIRE (skip_cfa_op (&p, end, length));
1025*fae548d3Szrj }
1026*fae548d3Szrj }
1027*fae548d3Szrj
1028*fae548d3Szrj this_inf->removed = 1;
1029*fae548d3Szrj this_inf->fde_encoding = cie->fde_encoding;
1030*fae548d3Szrj this_inf->lsda_encoding = cie->lsda_encoding;
1031*fae548d3Szrj sec_info->count++;
1032*fae548d3Szrj }
1033*fae548d3Szrj BFD_ASSERT (sec_info->count == num_entries);
1034*fae548d3Szrj BFD_ASSERT (cie_count == num_cies);
1035*fae548d3Szrj
1036*fae548d3Szrj elf_section_data (sec)->sec_info = sec_info;
1037*fae548d3Szrj sec->sec_info_type = SEC_INFO_TYPE_EH_FRAME;
1038*fae548d3Szrj if (!bfd_link_relocatable (info))
1039*fae548d3Szrj {
1040*fae548d3Szrj /* Keep info for merging cies. */
1041*fae548d3Szrj sec_info->cies = local_cies;
1042*fae548d3Szrj local_cies = NULL;
1043*fae548d3Szrj }
1044*fae548d3Szrj goto success;
1045*fae548d3Szrj
1046*fae548d3Szrj free_no_table:
1047*fae548d3Szrj _bfd_error_handler
1048*fae548d3Szrj /* xgettext:c-format */
1049*fae548d3Szrj (_("error in %pB(%pA); no .eh_frame_hdr table will be created"),
1050*fae548d3Szrj abfd, sec);
1051*fae548d3Szrj hdr_info->u.dwarf.table = FALSE;
1052*fae548d3Szrj if (sec_info)
1053*fae548d3Szrj free (sec_info);
1054*fae548d3Szrj success:
1055*fae548d3Szrj if (ehbuf)
1056*fae548d3Szrj free (ehbuf);
1057*fae548d3Szrj if (local_cies)
1058*fae548d3Szrj free (local_cies);
1059*fae548d3Szrj #undef REQUIRE
1060*fae548d3Szrj }
1061*fae548d3Szrj
1062*fae548d3Szrj /* Order eh_frame_hdr entries by the VMA of their text section. */
1063*fae548d3Szrj
1064*fae548d3Szrj static int
cmp_eh_frame_hdr(const void * a,const void * b)1065*fae548d3Szrj cmp_eh_frame_hdr (const void *a, const void *b)
1066*fae548d3Szrj {
1067*fae548d3Szrj bfd_vma text_a;
1068*fae548d3Szrj bfd_vma text_b;
1069*fae548d3Szrj asection *sec;
1070*fae548d3Szrj
1071*fae548d3Szrj sec = *(asection *const *)a;
1072*fae548d3Szrj sec = (asection *) elf_section_data (sec)->sec_info;
1073*fae548d3Szrj text_a = sec->output_section->vma + sec->output_offset;
1074*fae548d3Szrj sec = *(asection *const *)b;
1075*fae548d3Szrj sec = (asection *) elf_section_data (sec)->sec_info;
1076*fae548d3Szrj text_b = sec->output_section->vma + sec->output_offset;
1077*fae548d3Szrj
1078*fae548d3Szrj if (text_a < text_b)
1079*fae548d3Szrj return -1;
1080*fae548d3Szrj return text_a > text_b;
1081*fae548d3Szrj
1082*fae548d3Szrj }
1083*fae548d3Szrj
1084*fae548d3Szrj /* Add space for a CANTUNWIND terminator to SEC if the text sections
1085*fae548d3Szrj referenced by it and NEXT are not contiguous, or NEXT is NULL. */
1086*fae548d3Szrj
1087*fae548d3Szrj static void
add_eh_frame_hdr_terminator(asection * sec,asection * next)1088*fae548d3Szrj add_eh_frame_hdr_terminator (asection *sec,
1089*fae548d3Szrj asection *next)
1090*fae548d3Szrj {
1091*fae548d3Szrj bfd_vma end;
1092*fae548d3Szrj bfd_vma next_start;
1093*fae548d3Szrj asection *text_sec;
1094*fae548d3Szrj
1095*fae548d3Szrj if (next)
1096*fae548d3Szrj {
1097*fae548d3Szrj /* See if there is a gap (presumably a text section without unwind info)
1098*fae548d3Szrj between these two entries. */
1099*fae548d3Szrj text_sec = (asection *) elf_section_data (sec)->sec_info;
1100*fae548d3Szrj end = text_sec->output_section->vma + text_sec->output_offset
1101*fae548d3Szrj + text_sec->size;
1102*fae548d3Szrj text_sec = (asection *) elf_section_data (next)->sec_info;
1103*fae548d3Szrj next_start = text_sec->output_section->vma + text_sec->output_offset;
1104*fae548d3Szrj if (end == next_start)
1105*fae548d3Szrj return;
1106*fae548d3Szrj }
1107*fae548d3Szrj
1108*fae548d3Szrj /* Add space for a CANTUNWIND terminator. */
1109*fae548d3Szrj if (!sec->rawsize)
1110*fae548d3Szrj sec->rawsize = sec->size;
1111*fae548d3Szrj
1112*fae548d3Szrj bfd_set_section_size (sec, sec->size + 8);
1113*fae548d3Szrj }
1114*fae548d3Szrj
1115*fae548d3Szrj /* Finish a pass over all .eh_frame_entry sections. */
1116*fae548d3Szrj
1117*fae548d3Szrj bfd_boolean
_bfd_elf_end_eh_frame_parsing(struct bfd_link_info * info)1118*fae548d3Szrj _bfd_elf_end_eh_frame_parsing (struct bfd_link_info *info)
1119*fae548d3Szrj {
1120*fae548d3Szrj struct eh_frame_hdr_info *hdr_info;
1121*fae548d3Szrj unsigned int i;
1122*fae548d3Szrj
1123*fae548d3Szrj hdr_info = &elf_hash_table (info)->eh_info;
1124*fae548d3Szrj
1125*fae548d3Szrj if (info->eh_frame_hdr_type != COMPACT_EH_HDR
1126*fae548d3Szrj || hdr_info->array_count == 0)
1127*fae548d3Szrj return FALSE;
1128*fae548d3Szrj
1129*fae548d3Szrj bfd_elf_discard_eh_frame_entry (hdr_info);
1130*fae548d3Szrj
1131*fae548d3Szrj qsort (hdr_info->u.compact.entries, hdr_info->array_count,
1132*fae548d3Szrj sizeof (asection *), cmp_eh_frame_hdr);
1133*fae548d3Szrj
1134*fae548d3Szrj for (i = 0; i < hdr_info->array_count - 1; i++)
1135*fae548d3Szrj {
1136*fae548d3Szrj add_eh_frame_hdr_terminator (hdr_info->u.compact.entries[i],
1137*fae548d3Szrj hdr_info->u.compact.entries[i + 1]);
1138*fae548d3Szrj }
1139*fae548d3Szrj
1140*fae548d3Szrj /* Add a CANTUNWIND terminator after the last entry. */
1141*fae548d3Szrj add_eh_frame_hdr_terminator (hdr_info->u.compact.entries[i], NULL);
1142*fae548d3Szrj return TRUE;
1143*fae548d3Szrj }
1144*fae548d3Szrj
1145*fae548d3Szrj /* Mark all relocations against CIE or FDE ENT, which occurs in
1146*fae548d3Szrj .eh_frame section SEC. COOKIE describes the relocations in SEC;
1147*fae548d3Szrj its "rel" field can be changed freely. */
1148*fae548d3Szrj
1149*fae548d3Szrj static bfd_boolean
mark_entry(struct bfd_link_info * info,asection * sec,struct eh_cie_fde * ent,elf_gc_mark_hook_fn gc_mark_hook,struct elf_reloc_cookie * cookie)1150*fae548d3Szrj mark_entry (struct bfd_link_info *info, asection *sec,
1151*fae548d3Szrj struct eh_cie_fde *ent, elf_gc_mark_hook_fn gc_mark_hook,
1152*fae548d3Szrj struct elf_reloc_cookie *cookie)
1153*fae548d3Szrj {
1154*fae548d3Szrj /* FIXME: octets_per_byte. */
1155*fae548d3Szrj for (cookie->rel = cookie->rels + ent->reloc_index;
1156*fae548d3Szrj cookie->rel < cookie->relend
1157*fae548d3Szrj && cookie->rel->r_offset < ent->offset + ent->size;
1158*fae548d3Szrj cookie->rel++)
1159*fae548d3Szrj if (!_bfd_elf_gc_mark_reloc (info, sec, gc_mark_hook, cookie))
1160*fae548d3Szrj return FALSE;
1161*fae548d3Szrj
1162*fae548d3Szrj return TRUE;
1163*fae548d3Szrj }
1164*fae548d3Szrj
1165*fae548d3Szrj /* Mark all the relocations against FDEs that relate to code in input
1166*fae548d3Szrj section SEC. The FDEs belong to .eh_frame section EH_FRAME, whose
1167*fae548d3Szrj relocations are described by COOKIE. */
1168*fae548d3Szrj
1169*fae548d3Szrj bfd_boolean
_bfd_elf_gc_mark_fdes(struct bfd_link_info * info,asection * sec,asection * eh_frame,elf_gc_mark_hook_fn gc_mark_hook,struct elf_reloc_cookie * cookie)1170*fae548d3Szrj _bfd_elf_gc_mark_fdes (struct bfd_link_info *info, asection *sec,
1171*fae548d3Szrj asection *eh_frame, elf_gc_mark_hook_fn gc_mark_hook,
1172*fae548d3Szrj struct elf_reloc_cookie *cookie)
1173*fae548d3Szrj {
1174*fae548d3Szrj struct eh_cie_fde *fde, *cie;
1175*fae548d3Szrj
1176*fae548d3Szrj for (fde = elf_fde_list (sec); fde; fde = fde->u.fde.next_for_section)
1177*fae548d3Szrj {
1178*fae548d3Szrj if (!mark_entry (info, eh_frame, fde, gc_mark_hook, cookie))
1179*fae548d3Szrj return FALSE;
1180*fae548d3Szrj
1181*fae548d3Szrj /* At this stage, all cie_inf fields point to local CIEs, so we
1182*fae548d3Szrj can use the same cookie to refer to them. */
1183*fae548d3Szrj cie = fde->u.fde.cie_inf;
1184*fae548d3Szrj if (cie != NULL && !cie->u.cie.gc_mark)
1185*fae548d3Szrj {
1186*fae548d3Szrj cie->u.cie.gc_mark = 1;
1187*fae548d3Szrj if (!mark_entry (info, eh_frame, cie, gc_mark_hook, cookie))
1188*fae548d3Szrj return FALSE;
1189*fae548d3Szrj }
1190*fae548d3Szrj }
1191*fae548d3Szrj return TRUE;
1192*fae548d3Szrj }
1193*fae548d3Szrj
1194*fae548d3Szrj /* Input section SEC of ABFD is an .eh_frame section that contains the
1195*fae548d3Szrj CIE described by CIE_INF. Return a version of CIE_INF that is going
1196*fae548d3Szrj to be kept in the output, adding CIE_INF to the output if necessary.
1197*fae548d3Szrj
1198*fae548d3Szrj HDR_INFO is the .eh_frame_hdr information and COOKIE describes the
1199*fae548d3Szrj relocations in REL. */
1200*fae548d3Szrj
1201*fae548d3Szrj static struct eh_cie_fde *
find_merged_cie(bfd * abfd,struct bfd_link_info * info,asection * sec,struct eh_frame_hdr_info * hdr_info,struct elf_reloc_cookie * cookie,struct eh_cie_fde * cie_inf)1202*fae548d3Szrj find_merged_cie (bfd *abfd, struct bfd_link_info *info, asection *sec,
1203*fae548d3Szrj struct eh_frame_hdr_info *hdr_info,
1204*fae548d3Szrj struct elf_reloc_cookie *cookie,
1205*fae548d3Szrj struct eh_cie_fde *cie_inf)
1206*fae548d3Szrj {
1207*fae548d3Szrj unsigned long r_symndx;
1208*fae548d3Szrj struct cie *cie, *new_cie;
1209*fae548d3Szrj Elf_Internal_Rela *rel;
1210*fae548d3Szrj void **loc;
1211*fae548d3Szrj
1212*fae548d3Szrj /* Use CIE_INF if we have already decided to keep it. */
1213*fae548d3Szrj if (!cie_inf->removed)
1214*fae548d3Szrj return cie_inf;
1215*fae548d3Szrj
1216*fae548d3Szrj /* If we have merged CIE_INF with another CIE, use that CIE instead. */
1217*fae548d3Szrj if (cie_inf->u.cie.merged)
1218*fae548d3Szrj return cie_inf->u.cie.u.merged_with;
1219*fae548d3Szrj
1220*fae548d3Szrj cie = cie_inf->u.cie.u.full_cie;
1221*fae548d3Szrj
1222*fae548d3Szrj /* Assume we will need to keep CIE_INF. */
1223*fae548d3Szrj cie_inf->removed = 0;
1224*fae548d3Szrj cie_inf->u.cie.u.sec = sec;
1225*fae548d3Szrj
1226*fae548d3Szrj /* If we are not merging CIEs, use CIE_INF. */
1227*fae548d3Szrj if (cie == NULL)
1228*fae548d3Szrj return cie_inf;
1229*fae548d3Szrj
1230*fae548d3Szrj if (cie->per_encoding != DW_EH_PE_omit)
1231*fae548d3Szrj {
1232*fae548d3Szrj bfd_boolean per_binds_local;
1233*fae548d3Szrj
1234*fae548d3Szrj /* Work out the address of personality routine, or at least
1235*fae548d3Szrj enough info that we could calculate the address had we made a
1236*fae548d3Szrj final section layout. The symbol on the reloc is enough,
1237*fae548d3Szrj either the hash for a global, or (bfd id, index) pair for a
1238*fae548d3Szrj local. The assumption here is that no one uses addends on
1239*fae548d3Szrj the reloc. */
1240*fae548d3Szrj rel = cookie->rels + cie->personality.reloc_index;
1241*fae548d3Szrj memset (&cie->personality, 0, sizeof (cie->personality));
1242*fae548d3Szrj #ifdef BFD64
1243*fae548d3Szrj if (elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64)
1244*fae548d3Szrj r_symndx = ELF64_R_SYM (rel->r_info);
1245*fae548d3Szrj else
1246*fae548d3Szrj #endif
1247*fae548d3Szrj r_symndx = ELF32_R_SYM (rel->r_info);
1248*fae548d3Szrj if (r_symndx >= cookie->locsymcount
1249*fae548d3Szrj || ELF_ST_BIND (cookie->locsyms[r_symndx].st_info) != STB_LOCAL)
1250*fae548d3Szrj {
1251*fae548d3Szrj struct elf_link_hash_entry *h;
1252*fae548d3Szrj
1253*fae548d3Szrj r_symndx -= cookie->extsymoff;
1254*fae548d3Szrj h = cookie->sym_hashes[r_symndx];
1255*fae548d3Szrj
1256*fae548d3Szrj while (h->root.type == bfd_link_hash_indirect
1257*fae548d3Szrj || h->root.type == bfd_link_hash_warning)
1258*fae548d3Szrj h = (struct elf_link_hash_entry *) h->root.u.i.link;
1259*fae548d3Szrj
1260*fae548d3Szrj cie->personality.h = h;
1261*fae548d3Szrj per_binds_local = SYMBOL_REFERENCES_LOCAL (info, h);
1262*fae548d3Szrj }
1263*fae548d3Szrj else
1264*fae548d3Szrj {
1265*fae548d3Szrj Elf_Internal_Sym *sym;
1266*fae548d3Szrj asection *sym_sec;
1267*fae548d3Szrj
1268*fae548d3Szrj sym = &cookie->locsyms[r_symndx];
1269*fae548d3Szrj sym_sec = bfd_section_from_elf_index (abfd, sym->st_shndx);
1270*fae548d3Szrj if (sym_sec == NULL)
1271*fae548d3Szrj return cie_inf;
1272*fae548d3Szrj
1273*fae548d3Szrj if (sym_sec->kept_section != NULL)
1274*fae548d3Szrj sym_sec = sym_sec->kept_section;
1275*fae548d3Szrj if (sym_sec->output_section == NULL)
1276*fae548d3Szrj return cie_inf;
1277*fae548d3Szrj
1278*fae548d3Szrj cie->local_personality = 1;
1279*fae548d3Szrj cie->personality.sym.bfd_id = abfd->id;
1280*fae548d3Szrj cie->personality.sym.index = r_symndx;
1281*fae548d3Szrj per_binds_local = TRUE;
1282*fae548d3Szrj }
1283*fae548d3Szrj
1284*fae548d3Szrj if (per_binds_local
1285*fae548d3Szrj && bfd_link_pic (info)
1286*fae548d3Szrj && (cie->per_encoding & 0x70) == DW_EH_PE_absptr
1287*fae548d3Szrj && (get_elf_backend_data (abfd)
1288*fae548d3Szrj ->elf_backend_can_make_relative_eh_frame (abfd, info, sec)))
1289*fae548d3Szrj {
1290*fae548d3Szrj cie_inf->u.cie.make_per_encoding_relative = 1;
1291*fae548d3Szrj cie_inf->u.cie.per_encoding_relative = 1;
1292*fae548d3Szrj }
1293*fae548d3Szrj }
1294*fae548d3Szrj
1295*fae548d3Szrj /* See if we can merge this CIE with an earlier one. */
1296*fae548d3Szrj cie_compute_hash (cie);
1297*fae548d3Szrj if (hdr_info->u.dwarf.cies == NULL)
1298*fae548d3Szrj {
1299*fae548d3Szrj hdr_info->u.dwarf.cies = htab_try_create (1, cie_hash, cie_eq, free);
1300*fae548d3Szrj if (hdr_info->u.dwarf.cies == NULL)
1301*fae548d3Szrj return cie_inf;
1302*fae548d3Szrj }
1303*fae548d3Szrj loc = htab_find_slot_with_hash (hdr_info->u.dwarf.cies, cie,
1304*fae548d3Szrj cie->hash, INSERT);
1305*fae548d3Szrj if (loc == NULL)
1306*fae548d3Szrj return cie_inf;
1307*fae548d3Szrj
1308*fae548d3Szrj new_cie = (struct cie *) *loc;
1309*fae548d3Szrj if (new_cie == NULL)
1310*fae548d3Szrj {
1311*fae548d3Szrj /* Keep CIE_INF and record it in the hash table. */
1312*fae548d3Szrj new_cie = (struct cie *) malloc (sizeof (struct cie));
1313*fae548d3Szrj if (new_cie == NULL)
1314*fae548d3Szrj return cie_inf;
1315*fae548d3Szrj
1316*fae548d3Szrj memcpy (new_cie, cie, sizeof (struct cie));
1317*fae548d3Szrj *loc = new_cie;
1318*fae548d3Szrj }
1319*fae548d3Szrj else
1320*fae548d3Szrj {
1321*fae548d3Szrj /* Merge CIE_INF with NEW_CIE->CIE_INF. */
1322*fae548d3Szrj cie_inf->removed = 1;
1323*fae548d3Szrj cie_inf->u.cie.merged = 1;
1324*fae548d3Szrj cie_inf->u.cie.u.merged_with = new_cie->cie_inf;
1325*fae548d3Szrj if (cie_inf->u.cie.make_lsda_relative)
1326*fae548d3Szrj new_cie->cie_inf->u.cie.make_lsda_relative = 1;
1327*fae548d3Szrj }
1328*fae548d3Szrj return new_cie->cie_inf;
1329*fae548d3Szrj }
1330*fae548d3Szrj
1331*fae548d3Szrj /* For a given OFFSET in SEC, return the delta to the new location
1332*fae548d3Szrj after .eh_frame editing. */
1333*fae548d3Szrj
1334*fae548d3Szrj static bfd_signed_vma
offset_adjust(bfd_vma offset,const asection * sec)1335*fae548d3Szrj offset_adjust (bfd_vma offset, const asection *sec)
1336*fae548d3Szrj {
1337*fae548d3Szrj struct eh_frame_sec_info *sec_info
1338*fae548d3Szrj = (struct eh_frame_sec_info *) elf_section_data (sec)->sec_info;
1339*fae548d3Szrj unsigned int lo, hi, mid;
1340*fae548d3Szrj struct eh_cie_fde *ent = NULL;
1341*fae548d3Szrj bfd_signed_vma delta;
1342*fae548d3Szrj
1343*fae548d3Szrj lo = 0;
1344*fae548d3Szrj hi = sec_info->count;
1345*fae548d3Szrj if (hi == 0)
1346*fae548d3Szrj return 0;
1347*fae548d3Szrj
1348*fae548d3Szrj while (lo < hi)
1349*fae548d3Szrj {
1350*fae548d3Szrj mid = (lo + hi) / 2;
1351*fae548d3Szrj ent = &sec_info->entry[mid];
1352*fae548d3Szrj if (offset < ent->offset)
1353*fae548d3Szrj hi = mid;
1354*fae548d3Szrj else if (mid + 1 >= hi)
1355*fae548d3Szrj break;
1356*fae548d3Szrj else if (offset >= ent[1].offset)
1357*fae548d3Szrj lo = mid + 1;
1358*fae548d3Szrj else
1359*fae548d3Szrj break;
1360*fae548d3Szrj }
1361*fae548d3Szrj
1362*fae548d3Szrj if (!ent->removed)
1363*fae548d3Szrj delta = (bfd_vma) ent->new_offset - (bfd_vma) ent->offset;
1364*fae548d3Szrj else if (ent->cie && ent->u.cie.merged)
1365*fae548d3Szrj {
1366*fae548d3Szrj struct eh_cie_fde *cie = ent->u.cie.u.merged_with;
1367*fae548d3Szrj delta = ((bfd_vma) cie->new_offset + cie->u.cie.u.sec->output_offset
1368*fae548d3Szrj - (bfd_vma) ent->offset - sec->output_offset);
1369*fae548d3Szrj }
1370*fae548d3Szrj else
1371*fae548d3Szrj {
1372*fae548d3Szrj /* Is putting the symbol on the next entry best for a deleted
1373*fae548d3Szrj CIE/FDE? */
1374*fae548d3Szrj struct eh_cie_fde *last = sec_info->entry + sec_info->count;
1375*fae548d3Szrj delta = ((bfd_vma) next_cie_fde_offset (ent, last, sec)
1376*fae548d3Szrj - (bfd_vma) ent->offset);
1377*fae548d3Szrj return delta;
1378*fae548d3Szrj }
1379*fae548d3Szrj
1380*fae548d3Szrj /* Account for editing within this CIE/FDE. */
1381*fae548d3Szrj offset -= ent->offset;
1382*fae548d3Szrj if (ent->cie)
1383*fae548d3Szrj {
1384*fae548d3Szrj unsigned int extra
1385*fae548d3Szrj = ent->add_augmentation_size + ent->u.cie.add_fde_encoding;
1386*fae548d3Szrj if (extra == 0
1387*fae548d3Szrj || offset <= 9u + ent->u.cie.aug_str_len)
1388*fae548d3Szrj return delta;
1389*fae548d3Szrj delta += extra;
1390*fae548d3Szrj if (offset <= 9u + ent->u.cie.aug_str_len + ent->u.cie.aug_data_len)
1391*fae548d3Szrj return delta;
1392*fae548d3Szrj delta += extra;
1393*fae548d3Szrj }
1394*fae548d3Szrj else
1395*fae548d3Szrj {
1396*fae548d3Szrj unsigned int ptr_size, width, extra = ent->add_augmentation_size;
1397*fae548d3Szrj if (offset <= 12 || extra == 0)
1398*fae548d3Szrj return delta;
1399*fae548d3Szrj ptr_size = (get_elf_backend_data (sec->owner)
1400*fae548d3Szrj ->elf_backend_eh_frame_address_size (sec->owner, sec));
1401*fae548d3Szrj width = get_DW_EH_PE_width (ent->fde_encoding, ptr_size);
1402*fae548d3Szrj if (offset <= 8 + 2 * width)
1403*fae548d3Szrj return delta;
1404*fae548d3Szrj delta += extra;
1405*fae548d3Szrj }
1406*fae548d3Szrj
1407*fae548d3Szrj return delta;
1408*fae548d3Szrj }
1409*fae548d3Szrj
1410*fae548d3Szrj /* Adjust a global symbol defined in .eh_frame, so that it stays
1411*fae548d3Szrj relative to its original CIE/FDE. It is assumed that a symbol
1412*fae548d3Szrj defined at the beginning of a CIE/FDE belongs to that CIE/FDE
1413*fae548d3Szrj rather than marking the end of the previous CIE/FDE. This matters
1414*fae548d3Szrj when a CIE is merged with a previous CIE, since the symbol is
1415*fae548d3Szrj moved to the merged CIE. */
1416*fae548d3Szrj
1417*fae548d3Szrj bfd_boolean
_bfd_elf_adjust_eh_frame_global_symbol(struct elf_link_hash_entry * h,void * arg ATTRIBUTE_UNUSED)1418*fae548d3Szrj _bfd_elf_adjust_eh_frame_global_symbol (struct elf_link_hash_entry *h,
1419*fae548d3Szrj void *arg ATTRIBUTE_UNUSED)
1420*fae548d3Szrj {
1421*fae548d3Szrj asection *sym_sec;
1422*fae548d3Szrj bfd_signed_vma delta;
1423*fae548d3Szrj
1424*fae548d3Szrj if (h->root.type != bfd_link_hash_defined
1425*fae548d3Szrj && h->root.type != bfd_link_hash_defweak)
1426*fae548d3Szrj return TRUE;
1427*fae548d3Szrj
1428*fae548d3Szrj sym_sec = h->root.u.def.section;
1429*fae548d3Szrj if (sym_sec->sec_info_type != SEC_INFO_TYPE_EH_FRAME
1430*fae548d3Szrj || elf_section_data (sym_sec)->sec_info == NULL)
1431*fae548d3Szrj return TRUE;
1432*fae548d3Szrj
1433*fae548d3Szrj delta = offset_adjust (h->root.u.def.value, sym_sec);
1434*fae548d3Szrj h->root.u.def.value += delta;
1435*fae548d3Szrj
1436*fae548d3Szrj return TRUE;
1437*fae548d3Szrj }
1438*fae548d3Szrj
1439*fae548d3Szrj /* The same for all local symbols defined in .eh_frame. Returns true
1440*fae548d3Szrj if any symbol was changed. */
1441*fae548d3Szrj
1442*fae548d3Szrj static int
adjust_eh_frame_local_symbols(const asection * sec,struct elf_reloc_cookie * cookie)1443*fae548d3Szrj adjust_eh_frame_local_symbols (const asection *sec,
1444*fae548d3Szrj struct elf_reloc_cookie *cookie)
1445*fae548d3Szrj {
1446*fae548d3Szrj unsigned int shndx;
1447*fae548d3Szrj Elf_Internal_Sym *sym;
1448*fae548d3Szrj Elf_Internal_Sym *end_sym;
1449*fae548d3Szrj int adjusted = 0;
1450*fae548d3Szrj
1451*fae548d3Szrj shndx = elf_section_data (sec)->this_idx;
1452*fae548d3Szrj end_sym = cookie->locsyms + cookie->locsymcount;
1453*fae548d3Szrj for (sym = cookie->locsyms + 1; sym < end_sym; ++sym)
1454*fae548d3Szrj if (sym->st_info <= ELF_ST_INFO (STB_LOCAL, STT_OBJECT)
1455*fae548d3Szrj && sym->st_shndx == shndx)
1456*fae548d3Szrj {
1457*fae548d3Szrj bfd_signed_vma delta = offset_adjust (sym->st_value, sec);
1458*fae548d3Szrj
1459*fae548d3Szrj if (delta != 0)
1460*fae548d3Szrj {
1461*fae548d3Szrj adjusted = 1;
1462*fae548d3Szrj sym->st_value += delta;
1463*fae548d3Szrj }
1464*fae548d3Szrj }
1465*fae548d3Szrj return adjusted;
1466*fae548d3Szrj }
1467*fae548d3Szrj
1468*fae548d3Szrj /* This function is called for each input file before the .eh_frame
1469*fae548d3Szrj section is relocated. It discards duplicate CIEs and FDEs for discarded
1470*fae548d3Szrj functions. The function returns TRUE iff any entries have been
1471*fae548d3Szrj deleted. */
1472*fae548d3Szrj
1473*fae548d3Szrj bfd_boolean
_bfd_elf_discard_section_eh_frame(bfd * abfd,struct bfd_link_info * info,asection * sec,bfd_boolean (* reloc_symbol_deleted_p)(bfd_vma,void *),struct elf_reloc_cookie * cookie)1474*fae548d3Szrj _bfd_elf_discard_section_eh_frame
1475*fae548d3Szrj (bfd *abfd, struct bfd_link_info *info, asection *sec,
1476*fae548d3Szrj bfd_boolean (*reloc_symbol_deleted_p) (bfd_vma, void *),
1477*fae548d3Szrj struct elf_reloc_cookie *cookie)
1478*fae548d3Szrj {
1479*fae548d3Szrj struct eh_cie_fde *ent;
1480*fae548d3Szrj struct eh_frame_sec_info *sec_info;
1481*fae548d3Szrj struct eh_frame_hdr_info *hdr_info;
1482*fae548d3Szrj unsigned int ptr_size, offset, eh_alignment;
1483*fae548d3Szrj int changed;
1484*fae548d3Szrj
1485*fae548d3Szrj if (sec->sec_info_type != SEC_INFO_TYPE_EH_FRAME)
1486*fae548d3Szrj return FALSE;
1487*fae548d3Szrj
1488*fae548d3Szrj sec_info = (struct eh_frame_sec_info *) elf_section_data (sec)->sec_info;
1489*fae548d3Szrj if (sec_info == NULL)
1490*fae548d3Szrj return FALSE;
1491*fae548d3Szrj
1492*fae548d3Szrj ptr_size = (get_elf_backend_data (sec->owner)
1493*fae548d3Szrj ->elf_backend_eh_frame_address_size (sec->owner, sec));
1494*fae548d3Szrj
1495*fae548d3Szrj hdr_info = &elf_hash_table (info)->eh_info;
1496*fae548d3Szrj for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent)
1497*fae548d3Szrj if (ent->size == 4)
1498*fae548d3Szrj /* There should only be one zero terminator, on the last input
1499*fae548d3Szrj file supplying .eh_frame (crtend.o). Remove any others. */
1500*fae548d3Szrj ent->removed = sec->map_head.s != NULL;
1501*fae548d3Szrj else if (!ent->cie && ent->u.fde.cie_inf != NULL)
1502*fae548d3Szrj {
1503*fae548d3Szrj bfd_boolean keep;
1504*fae548d3Szrj if ((sec->flags & SEC_LINKER_CREATED) != 0 && cookie->rels == NULL)
1505*fae548d3Szrj {
1506*fae548d3Szrj unsigned int width
1507*fae548d3Szrj = get_DW_EH_PE_width (ent->fde_encoding, ptr_size);
1508*fae548d3Szrj bfd_vma value
1509*fae548d3Szrj = read_value (abfd, sec->contents + ent->offset + 8 + width,
1510*fae548d3Szrj width, get_DW_EH_PE_signed (ent->fde_encoding));
1511*fae548d3Szrj keep = value != 0;
1512*fae548d3Szrj }
1513*fae548d3Szrj else
1514*fae548d3Szrj {
1515*fae548d3Szrj cookie->rel = cookie->rels + ent->reloc_index;
1516*fae548d3Szrj /* FIXME: octets_per_byte. */
1517*fae548d3Szrj BFD_ASSERT (cookie->rel < cookie->relend
1518*fae548d3Szrj && cookie->rel->r_offset == ent->offset + 8);
1519*fae548d3Szrj keep = !(*reloc_symbol_deleted_p) (ent->offset + 8, cookie);
1520*fae548d3Szrj }
1521*fae548d3Szrj if (keep)
1522*fae548d3Szrj {
1523*fae548d3Szrj if (bfd_link_pic (info)
1524*fae548d3Szrj && (((ent->fde_encoding & 0x70) == DW_EH_PE_absptr
1525*fae548d3Szrj && ent->make_relative == 0)
1526*fae548d3Szrj || (ent->fde_encoding & 0x70) == DW_EH_PE_aligned))
1527*fae548d3Szrj {
1528*fae548d3Szrj static int num_warnings_issued = 0;
1529*fae548d3Szrj
1530*fae548d3Szrj /* If a shared library uses absolute pointers
1531*fae548d3Szrj which we cannot turn into PC relative,
1532*fae548d3Szrj don't create the binary search table,
1533*fae548d3Szrj since it is affected by runtime relocations. */
1534*fae548d3Szrj hdr_info->u.dwarf.table = FALSE;
1535*fae548d3Szrj /* Only warn if --eh-frame-hdr was specified. */
1536*fae548d3Szrj if (info->eh_frame_hdr_type != 0)
1537*fae548d3Szrj {
1538*fae548d3Szrj if (num_warnings_issued < 10)
1539*fae548d3Szrj {
1540*fae548d3Szrj _bfd_error_handler
1541*fae548d3Szrj /* xgettext:c-format */
1542*fae548d3Szrj (_("FDE encoding in %pB(%pA) prevents .eh_frame_hdr"
1543*fae548d3Szrj " table being created"), abfd, sec);
1544*fae548d3Szrj num_warnings_issued ++;
1545*fae548d3Szrj }
1546*fae548d3Szrj else if (num_warnings_issued == 10)
1547*fae548d3Szrj {
1548*fae548d3Szrj _bfd_error_handler
1549*fae548d3Szrj (_("further warnings about FDE encoding preventing .eh_frame_hdr generation dropped"));
1550*fae548d3Szrj num_warnings_issued ++;
1551*fae548d3Szrj }
1552*fae548d3Szrj }
1553*fae548d3Szrj }
1554*fae548d3Szrj ent->removed = 0;
1555*fae548d3Szrj hdr_info->u.dwarf.fde_count++;
1556*fae548d3Szrj ent->u.fde.cie_inf = find_merged_cie (abfd, info, sec, hdr_info,
1557*fae548d3Szrj cookie, ent->u.fde.cie_inf);
1558*fae548d3Szrj }
1559*fae548d3Szrj }
1560*fae548d3Szrj
1561*fae548d3Szrj if (sec_info->cies)
1562*fae548d3Szrj {
1563*fae548d3Szrj free (sec_info->cies);
1564*fae548d3Szrj sec_info->cies = NULL;
1565*fae548d3Szrj }
1566*fae548d3Szrj
1567*fae548d3Szrj /* It may be that some .eh_frame input section has greater alignment
1568*fae548d3Szrj than other .eh_frame sections. In that case we run the risk of
1569*fae548d3Szrj padding with zeros before that section, which would be seen as a
1570*fae548d3Szrj zero terminator. Alignment padding must be added *inside* the
1571*fae548d3Szrj last FDE instead. For other FDEs we align according to their
1572*fae548d3Szrj encoding, in order to align FDE address range entries naturally. */
1573*fae548d3Szrj offset = 0;
1574*fae548d3Szrj changed = 0;
1575*fae548d3Szrj for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent)
1576*fae548d3Szrj if (!ent->removed)
1577*fae548d3Szrj {
1578*fae548d3Szrj eh_alignment = 4;
1579*fae548d3Szrj if (ent->size == 4)
1580*fae548d3Szrj ;
1581*fae548d3Szrj else if (ent->cie)
1582*fae548d3Szrj {
1583*fae548d3Szrj if (ent->u.cie.per_encoding_aligned8)
1584*fae548d3Szrj eh_alignment = 8;
1585*fae548d3Szrj }
1586*fae548d3Szrj else
1587*fae548d3Szrj {
1588*fae548d3Szrj eh_alignment = get_DW_EH_PE_width (ent->fde_encoding, ptr_size);
1589*fae548d3Szrj if (eh_alignment < 4)
1590*fae548d3Szrj eh_alignment = 4;
1591*fae548d3Szrj }
1592*fae548d3Szrj offset = (offset + eh_alignment - 1) & -eh_alignment;
1593*fae548d3Szrj ent->new_offset = offset;
1594*fae548d3Szrj if (ent->new_offset != ent->offset)
1595*fae548d3Szrj changed = 1;
1596*fae548d3Szrj offset += size_of_output_cie_fde (ent);
1597*fae548d3Szrj }
1598*fae548d3Szrj
1599*fae548d3Szrj eh_alignment = 4;
1600*fae548d3Szrj offset = (offset + eh_alignment - 1) & -eh_alignment;
1601*fae548d3Szrj sec->rawsize = sec->size;
1602*fae548d3Szrj sec->size = offset;
1603*fae548d3Szrj if (sec->size != sec->rawsize)
1604*fae548d3Szrj changed = 1;
1605*fae548d3Szrj
1606*fae548d3Szrj if (changed && adjust_eh_frame_local_symbols (sec, cookie))
1607*fae548d3Szrj {
1608*fae548d3Szrj Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1609*fae548d3Szrj symtab_hdr->contents = (unsigned char *) cookie->locsyms;
1610*fae548d3Szrj }
1611*fae548d3Szrj return changed;
1612*fae548d3Szrj }
1613*fae548d3Szrj
1614*fae548d3Szrj /* This function is called for .eh_frame_hdr section after
1615*fae548d3Szrj _bfd_elf_discard_section_eh_frame has been called on all .eh_frame
1616*fae548d3Szrj input sections. It finalizes the size of .eh_frame_hdr section. */
1617*fae548d3Szrj
1618*fae548d3Szrj bfd_boolean
_bfd_elf_discard_section_eh_frame_hdr(bfd * abfd,struct bfd_link_info * info)1619*fae548d3Szrj _bfd_elf_discard_section_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info)
1620*fae548d3Szrj {
1621*fae548d3Szrj struct elf_link_hash_table *htab;
1622*fae548d3Szrj struct eh_frame_hdr_info *hdr_info;
1623*fae548d3Szrj asection *sec;
1624*fae548d3Szrj
1625*fae548d3Szrj htab = elf_hash_table (info);
1626*fae548d3Szrj hdr_info = &htab->eh_info;
1627*fae548d3Szrj
1628*fae548d3Szrj if (!hdr_info->frame_hdr_is_compact && hdr_info->u.dwarf.cies != NULL)
1629*fae548d3Szrj {
1630*fae548d3Szrj htab_delete (hdr_info->u.dwarf.cies);
1631*fae548d3Szrj hdr_info->u.dwarf.cies = NULL;
1632*fae548d3Szrj }
1633*fae548d3Szrj
1634*fae548d3Szrj sec = hdr_info->hdr_sec;
1635*fae548d3Szrj if (sec == NULL)
1636*fae548d3Szrj return FALSE;
1637*fae548d3Szrj
1638*fae548d3Szrj if (info->eh_frame_hdr_type == COMPACT_EH_HDR)
1639*fae548d3Szrj {
1640*fae548d3Szrj /* For compact frames we only add the header. The actual table comes
1641*fae548d3Szrj from the .eh_frame_entry sections. */
1642*fae548d3Szrj sec->size = 8;
1643*fae548d3Szrj }
1644*fae548d3Szrj else
1645*fae548d3Szrj {
1646*fae548d3Szrj sec->size = EH_FRAME_HDR_SIZE;
1647*fae548d3Szrj if (hdr_info->u.dwarf.table)
1648*fae548d3Szrj sec->size += 4 + hdr_info->u.dwarf.fde_count * 8;
1649*fae548d3Szrj }
1650*fae548d3Szrj
1651*fae548d3Szrj elf_eh_frame_hdr (abfd) = sec;
1652*fae548d3Szrj return TRUE;
1653*fae548d3Szrj }
1654*fae548d3Szrj
1655*fae548d3Szrj /* Return true if there is at least one non-empty .eh_frame section in
1656*fae548d3Szrj input files. Can only be called after ld has mapped input to
1657*fae548d3Szrj output sections, and before sections are stripped. */
1658*fae548d3Szrj
1659*fae548d3Szrj bfd_boolean
_bfd_elf_eh_frame_present(struct bfd_link_info * info)1660*fae548d3Szrj _bfd_elf_eh_frame_present (struct bfd_link_info *info)
1661*fae548d3Szrj {
1662*fae548d3Szrj asection *eh = bfd_get_section_by_name (info->output_bfd, ".eh_frame");
1663*fae548d3Szrj
1664*fae548d3Szrj if (eh == NULL)
1665*fae548d3Szrj return FALSE;
1666*fae548d3Szrj
1667*fae548d3Szrj /* Count only sections which have at least a single CIE or FDE.
1668*fae548d3Szrj There cannot be any CIE or FDE <= 8 bytes. */
1669*fae548d3Szrj for (eh = eh->map_head.s; eh != NULL; eh = eh->map_head.s)
1670*fae548d3Szrj if (eh->size > 8)
1671*fae548d3Szrj return TRUE;
1672*fae548d3Szrj
1673*fae548d3Szrj return FALSE;
1674*fae548d3Szrj }
1675*fae548d3Szrj
1676*fae548d3Szrj /* Return true if there is at least one .eh_frame_entry section in
1677*fae548d3Szrj input files. */
1678*fae548d3Szrj
1679*fae548d3Szrj bfd_boolean
_bfd_elf_eh_frame_entry_present(struct bfd_link_info * info)1680*fae548d3Szrj _bfd_elf_eh_frame_entry_present (struct bfd_link_info *info)
1681*fae548d3Szrj {
1682*fae548d3Szrj asection *o;
1683*fae548d3Szrj bfd *abfd;
1684*fae548d3Szrj
1685*fae548d3Szrj for (abfd = info->input_bfds; abfd != NULL; abfd = abfd->link.next)
1686*fae548d3Szrj {
1687*fae548d3Szrj for (o = abfd->sections; o; o = o->next)
1688*fae548d3Szrj {
1689*fae548d3Szrj const char *name = bfd_section_name (o);
1690*fae548d3Szrj
1691*fae548d3Szrj if (strcmp (name, ".eh_frame_entry")
1692*fae548d3Szrj && !bfd_is_abs_section (o->output_section))
1693*fae548d3Szrj return TRUE;
1694*fae548d3Szrj }
1695*fae548d3Szrj }
1696*fae548d3Szrj return FALSE;
1697*fae548d3Szrj }
1698*fae548d3Szrj
1699*fae548d3Szrj /* This function is called from size_dynamic_sections.
1700*fae548d3Szrj It needs to decide whether .eh_frame_hdr should be output or not,
1701*fae548d3Szrj because when the dynamic symbol table has been sized it is too late
1702*fae548d3Szrj to strip sections. */
1703*fae548d3Szrj
1704*fae548d3Szrj bfd_boolean
_bfd_elf_maybe_strip_eh_frame_hdr(struct bfd_link_info * info)1705*fae548d3Szrj _bfd_elf_maybe_strip_eh_frame_hdr (struct bfd_link_info *info)
1706*fae548d3Szrj {
1707*fae548d3Szrj struct elf_link_hash_table *htab;
1708*fae548d3Szrj struct eh_frame_hdr_info *hdr_info;
1709*fae548d3Szrj struct bfd_link_hash_entry *bh = NULL;
1710*fae548d3Szrj struct elf_link_hash_entry *h;
1711*fae548d3Szrj
1712*fae548d3Szrj htab = elf_hash_table (info);
1713*fae548d3Szrj hdr_info = &htab->eh_info;
1714*fae548d3Szrj if (hdr_info->hdr_sec == NULL)
1715*fae548d3Szrj return TRUE;
1716*fae548d3Szrj
1717*fae548d3Szrj if (bfd_is_abs_section (hdr_info->hdr_sec->output_section)
1718*fae548d3Szrj || info->eh_frame_hdr_type == 0
1719*fae548d3Szrj || (info->eh_frame_hdr_type == DWARF2_EH_HDR
1720*fae548d3Szrj && !_bfd_elf_eh_frame_present (info))
1721*fae548d3Szrj || (info->eh_frame_hdr_type == COMPACT_EH_HDR
1722*fae548d3Szrj && !_bfd_elf_eh_frame_entry_present (info)))
1723*fae548d3Szrj {
1724*fae548d3Szrj hdr_info->hdr_sec->flags |= SEC_EXCLUDE;
1725*fae548d3Szrj hdr_info->hdr_sec = NULL;
1726*fae548d3Szrj return TRUE;
1727*fae548d3Szrj }
1728*fae548d3Szrj
1729*fae548d3Szrj /* Add a hidden symbol so that systems without access to PHDRs can
1730*fae548d3Szrj find the table. */
1731*fae548d3Szrj if (! (_bfd_generic_link_add_one_symbol
1732*fae548d3Szrj (info, info->output_bfd, "__GNU_EH_FRAME_HDR", BSF_LOCAL,
1733*fae548d3Szrj hdr_info->hdr_sec, 0, NULL, FALSE, FALSE, &bh)))
1734*fae548d3Szrj return FALSE;
1735*fae548d3Szrj
1736*fae548d3Szrj h = (struct elf_link_hash_entry *) bh;
1737*fae548d3Szrj h->def_regular = 1;
1738*fae548d3Szrj h->other = STV_HIDDEN;
1739*fae548d3Szrj get_elf_backend_data
1740*fae548d3Szrj (info->output_bfd)->elf_backend_hide_symbol (info, h, TRUE);
1741*fae548d3Szrj
1742*fae548d3Szrj if (!hdr_info->frame_hdr_is_compact)
1743*fae548d3Szrj hdr_info->u.dwarf.table = TRUE;
1744*fae548d3Szrj return TRUE;
1745*fae548d3Szrj }
1746*fae548d3Szrj
1747*fae548d3Szrj /* Adjust an address in the .eh_frame section. Given OFFSET within
1748*fae548d3Szrj SEC, this returns the new offset in the adjusted .eh_frame section,
1749*fae548d3Szrj or -1 if the address refers to a CIE/FDE which has been removed
1750*fae548d3Szrj or to offset with dynamic relocation which is no longer needed. */
1751*fae548d3Szrj
1752*fae548d3Szrj bfd_vma
_bfd_elf_eh_frame_section_offset(bfd * output_bfd ATTRIBUTE_UNUSED,struct bfd_link_info * info ATTRIBUTE_UNUSED,asection * sec,bfd_vma offset)1753*fae548d3Szrj _bfd_elf_eh_frame_section_offset (bfd *output_bfd ATTRIBUTE_UNUSED,
1754*fae548d3Szrj struct bfd_link_info *info ATTRIBUTE_UNUSED,
1755*fae548d3Szrj asection *sec,
1756*fae548d3Szrj bfd_vma offset)
1757*fae548d3Szrj {
1758*fae548d3Szrj struct eh_frame_sec_info *sec_info;
1759*fae548d3Szrj unsigned int lo, hi, mid;
1760*fae548d3Szrj
1761*fae548d3Szrj if (sec->sec_info_type != SEC_INFO_TYPE_EH_FRAME)
1762*fae548d3Szrj return offset;
1763*fae548d3Szrj sec_info = (struct eh_frame_sec_info *) elf_section_data (sec)->sec_info;
1764*fae548d3Szrj
1765*fae548d3Szrj if (offset >= sec->rawsize)
1766*fae548d3Szrj return offset - sec->rawsize + sec->size;
1767*fae548d3Szrj
1768*fae548d3Szrj lo = 0;
1769*fae548d3Szrj hi = sec_info->count;
1770*fae548d3Szrj mid = 0;
1771*fae548d3Szrj while (lo < hi)
1772*fae548d3Szrj {
1773*fae548d3Szrj mid = (lo + hi) / 2;
1774*fae548d3Szrj if (offset < sec_info->entry[mid].offset)
1775*fae548d3Szrj hi = mid;
1776*fae548d3Szrj else if (offset
1777*fae548d3Szrj >= sec_info->entry[mid].offset + sec_info->entry[mid].size)
1778*fae548d3Szrj lo = mid + 1;
1779*fae548d3Szrj else
1780*fae548d3Szrj break;
1781*fae548d3Szrj }
1782*fae548d3Szrj
1783*fae548d3Szrj BFD_ASSERT (lo < hi);
1784*fae548d3Szrj
1785*fae548d3Szrj /* FDE or CIE was removed. */
1786*fae548d3Szrj if (sec_info->entry[mid].removed)
1787*fae548d3Szrj return (bfd_vma) -1;
1788*fae548d3Szrj
1789*fae548d3Szrj /* If converting personality pointers to DW_EH_PE_pcrel, there will be
1790*fae548d3Szrj no need for run-time relocation against the personality field. */
1791*fae548d3Szrj if (sec_info->entry[mid].cie
1792*fae548d3Szrj && sec_info->entry[mid].u.cie.make_per_encoding_relative
1793*fae548d3Szrj && offset == (sec_info->entry[mid].offset + 8
1794*fae548d3Szrj + sec_info->entry[mid].u.cie.personality_offset))
1795*fae548d3Szrj return (bfd_vma) -2;
1796*fae548d3Szrj
1797*fae548d3Szrj /* If converting to DW_EH_PE_pcrel, there will be no need for run-time
1798*fae548d3Szrj relocation against FDE's initial_location field. */
1799*fae548d3Szrj if (!sec_info->entry[mid].cie
1800*fae548d3Szrj && sec_info->entry[mid].make_relative
1801*fae548d3Szrj && offset == sec_info->entry[mid].offset + 8)
1802*fae548d3Szrj return (bfd_vma) -2;
1803*fae548d3Szrj
1804*fae548d3Szrj /* If converting LSDA pointers to DW_EH_PE_pcrel, there will be no need
1805*fae548d3Szrj for run-time relocation against LSDA field. */
1806*fae548d3Szrj if (!sec_info->entry[mid].cie
1807*fae548d3Szrj && sec_info->entry[mid].u.fde.cie_inf->u.cie.make_lsda_relative
1808*fae548d3Szrj && offset == (sec_info->entry[mid].offset + 8
1809*fae548d3Szrj + sec_info->entry[mid].lsda_offset))
1810*fae548d3Szrj return (bfd_vma) -2;
1811*fae548d3Szrj
1812*fae548d3Szrj /* If converting to DW_EH_PE_pcrel, there will be no need for run-time
1813*fae548d3Szrj relocation against DW_CFA_set_loc's arguments. */
1814*fae548d3Szrj if (sec_info->entry[mid].set_loc
1815*fae548d3Szrj && sec_info->entry[mid].make_relative
1816*fae548d3Szrj && (offset >= sec_info->entry[mid].offset + 8
1817*fae548d3Szrj + sec_info->entry[mid].set_loc[1]))
1818*fae548d3Szrj {
1819*fae548d3Szrj unsigned int cnt;
1820*fae548d3Szrj
1821*fae548d3Szrj for (cnt = 1; cnt <= sec_info->entry[mid].set_loc[0]; cnt++)
1822*fae548d3Szrj if (offset == sec_info->entry[mid].offset + 8
1823*fae548d3Szrj + sec_info->entry[mid].set_loc[cnt])
1824*fae548d3Szrj return (bfd_vma) -2;
1825*fae548d3Szrj }
1826*fae548d3Szrj
1827*fae548d3Szrj /* Any new augmentation bytes go before the first relocation. */
1828*fae548d3Szrj return (offset + sec_info->entry[mid].new_offset
1829*fae548d3Szrj - sec_info->entry[mid].offset
1830*fae548d3Szrj + extra_augmentation_string_bytes (sec_info->entry + mid)
1831*fae548d3Szrj + extra_augmentation_data_bytes (sec_info->entry + mid));
1832*fae548d3Szrj }
1833*fae548d3Szrj
1834*fae548d3Szrj /* Write out .eh_frame_entry section. Add CANTUNWIND terminator if needed.
1835*fae548d3Szrj Also check that the contents look sane. */
1836*fae548d3Szrj
1837*fae548d3Szrj bfd_boolean
_bfd_elf_write_section_eh_frame_entry(bfd * abfd,struct bfd_link_info * info,asection * sec,bfd_byte * contents)1838*fae548d3Szrj _bfd_elf_write_section_eh_frame_entry (bfd *abfd, struct bfd_link_info *info,
1839*fae548d3Szrj asection *sec, bfd_byte *contents)
1840*fae548d3Szrj {
1841*fae548d3Szrj const struct elf_backend_data *bed;
1842*fae548d3Szrj bfd_byte cantunwind[8];
1843*fae548d3Szrj bfd_vma addr;
1844*fae548d3Szrj bfd_vma last_addr;
1845*fae548d3Szrj bfd_vma offset;
1846*fae548d3Szrj asection *text_sec = (asection *) elf_section_data (sec)->sec_info;
1847*fae548d3Szrj
1848*fae548d3Szrj if (!sec->rawsize)
1849*fae548d3Szrj sec->rawsize = sec->size;
1850*fae548d3Szrj
1851*fae548d3Szrj BFD_ASSERT (sec->sec_info_type == SEC_INFO_TYPE_EH_FRAME_ENTRY);
1852*fae548d3Szrj
1853*fae548d3Szrj /* Check to make sure that the text section corresponding to this eh_frame_entry
1854*fae548d3Szrj section has not been excluded. In particular, mips16 stub entries will be
1855*fae548d3Szrj excluded outside of the normal process. */
1856*fae548d3Szrj if (sec->flags & SEC_EXCLUDE
1857*fae548d3Szrj || text_sec->flags & SEC_EXCLUDE)
1858*fae548d3Szrj return TRUE;
1859*fae548d3Szrj
1860*fae548d3Szrj if (!bfd_set_section_contents (abfd, sec->output_section, contents,
1861*fae548d3Szrj sec->output_offset, sec->rawsize))
1862*fae548d3Szrj return FALSE;
1863*fae548d3Szrj
1864*fae548d3Szrj last_addr = bfd_get_signed_32 (abfd, contents);
1865*fae548d3Szrj /* Check that all the entries are in order. */
1866*fae548d3Szrj for (offset = 8; offset < sec->rawsize; offset += 8)
1867*fae548d3Szrj {
1868*fae548d3Szrj addr = bfd_get_signed_32 (abfd, contents + offset) + offset;
1869*fae548d3Szrj if (addr <= last_addr)
1870*fae548d3Szrj {
1871*fae548d3Szrj /* xgettext:c-format */
1872*fae548d3Szrj _bfd_error_handler (_("%pB: %pA not in order"), sec->owner, sec);
1873*fae548d3Szrj return FALSE;
1874*fae548d3Szrj }
1875*fae548d3Szrj
1876*fae548d3Szrj last_addr = addr;
1877*fae548d3Szrj }
1878*fae548d3Szrj
1879*fae548d3Szrj addr = text_sec->output_section->vma + text_sec->output_offset
1880*fae548d3Szrj + text_sec->size;
1881*fae548d3Szrj addr &= ~1;
1882*fae548d3Szrj addr -= (sec->output_section->vma + sec->output_offset + sec->rawsize);
1883*fae548d3Szrj if (addr & 1)
1884*fae548d3Szrj {
1885*fae548d3Szrj /* xgettext:c-format */
1886*fae548d3Szrj _bfd_error_handler (_("%pB: %pA invalid input section size"),
1887*fae548d3Szrj sec->owner, sec);
1888*fae548d3Szrj bfd_set_error (bfd_error_bad_value);
1889*fae548d3Szrj return FALSE;
1890*fae548d3Szrj }
1891*fae548d3Szrj if (last_addr >= addr + sec->rawsize)
1892*fae548d3Szrj {
1893*fae548d3Szrj /* xgettext:c-format */
1894*fae548d3Szrj _bfd_error_handler (_("%pB: %pA points past end of text section"),
1895*fae548d3Szrj sec->owner, sec);
1896*fae548d3Szrj bfd_set_error (bfd_error_bad_value);
1897*fae548d3Szrj return FALSE;
1898*fae548d3Szrj }
1899*fae548d3Szrj
1900*fae548d3Szrj if (sec->size == sec->rawsize)
1901*fae548d3Szrj return TRUE;
1902*fae548d3Szrj
1903*fae548d3Szrj bed = get_elf_backend_data (abfd);
1904*fae548d3Szrj BFD_ASSERT (sec->size == sec->rawsize + 8);
1905*fae548d3Szrj BFD_ASSERT ((addr & 1) == 0);
1906*fae548d3Szrj BFD_ASSERT (bed->cant_unwind_opcode);
1907*fae548d3Szrj
1908*fae548d3Szrj bfd_put_32 (abfd, addr, cantunwind);
1909*fae548d3Szrj bfd_put_32 (abfd, (*bed->cant_unwind_opcode) (info), cantunwind + 4);
1910*fae548d3Szrj return bfd_set_section_contents (abfd, sec->output_section, cantunwind,
1911*fae548d3Szrj sec->output_offset + sec->rawsize, 8);
1912*fae548d3Szrj }
1913*fae548d3Szrj
1914*fae548d3Szrj /* Write out .eh_frame section. This is called with the relocated
1915*fae548d3Szrj contents. */
1916*fae548d3Szrj
1917*fae548d3Szrj bfd_boolean
_bfd_elf_write_section_eh_frame(bfd * abfd,struct bfd_link_info * info,asection * sec,bfd_byte * contents)1918*fae548d3Szrj _bfd_elf_write_section_eh_frame (bfd *abfd,
1919*fae548d3Szrj struct bfd_link_info *info,
1920*fae548d3Szrj asection *sec,
1921*fae548d3Szrj bfd_byte *contents)
1922*fae548d3Szrj {
1923*fae548d3Szrj struct eh_frame_sec_info *sec_info;
1924*fae548d3Szrj struct elf_link_hash_table *htab;
1925*fae548d3Szrj struct eh_frame_hdr_info *hdr_info;
1926*fae548d3Szrj unsigned int ptr_size;
1927*fae548d3Szrj struct eh_cie_fde *ent, *last_ent;
1928*fae548d3Szrj
1929*fae548d3Szrj if (sec->sec_info_type != SEC_INFO_TYPE_EH_FRAME)
1930*fae548d3Szrj /* FIXME: octets_per_byte. */
1931*fae548d3Szrj return bfd_set_section_contents (abfd, sec->output_section, contents,
1932*fae548d3Szrj sec->output_offset, sec->size);
1933*fae548d3Szrj
1934*fae548d3Szrj ptr_size = (get_elf_backend_data (abfd)
1935*fae548d3Szrj ->elf_backend_eh_frame_address_size (abfd, sec));
1936*fae548d3Szrj BFD_ASSERT (ptr_size != 0);
1937*fae548d3Szrj
1938*fae548d3Szrj sec_info = (struct eh_frame_sec_info *) elf_section_data (sec)->sec_info;
1939*fae548d3Szrj htab = elf_hash_table (info);
1940*fae548d3Szrj hdr_info = &htab->eh_info;
1941*fae548d3Szrj
1942*fae548d3Szrj if (hdr_info->u.dwarf.table && hdr_info->u.dwarf.array == NULL)
1943*fae548d3Szrj {
1944*fae548d3Szrj hdr_info->frame_hdr_is_compact = FALSE;
1945*fae548d3Szrj hdr_info->u.dwarf.array = (struct eh_frame_array_ent *)
1946*fae548d3Szrj bfd_malloc (hdr_info->u.dwarf.fde_count
1947*fae548d3Szrj * sizeof (*hdr_info->u.dwarf.array));
1948*fae548d3Szrj }
1949*fae548d3Szrj if (hdr_info->u.dwarf.array == NULL)
1950*fae548d3Szrj hdr_info = NULL;
1951*fae548d3Szrj
1952*fae548d3Szrj /* The new offsets can be bigger or smaller than the original offsets.
1953*fae548d3Szrj We therefore need to make two passes over the section: one backward
1954*fae548d3Szrj pass to move entries up and one forward pass to move entries down.
1955*fae548d3Szrj The two passes won't interfere with each other because entries are
1956*fae548d3Szrj not reordered */
1957*fae548d3Szrj for (ent = sec_info->entry + sec_info->count; ent-- != sec_info->entry;)
1958*fae548d3Szrj if (!ent->removed && ent->new_offset > ent->offset)
1959*fae548d3Szrj memmove (contents + ent->new_offset, contents + ent->offset, ent->size);
1960*fae548d3Szrj
1961*fae548d3Szrj for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent)
1962*fae548d3Szrj if (!ent->removed && ent->new_offset < ent->offset)
1963*fae548d3Szrj memmove (contents + ent->new_offset, contents + ent->offset, ent->size);
1964*fae548d3Szrj
1965*fae548d3Szrj last_ent = sec_info->entry + sec_info->count;
1966*fae548d3Szrj for (ent = sec_info->entry; ent < last_ent; ++ent)
1967*fae548d3Szrj {
1968*fae548d3Szrj unsigned char *buf, *end;
1969*fae548d3Szrj unsigned int new_size;
1970*fae548d3Szrj
1971*fae548d3Szrj if (ent->removed)
1972*fae548d3Szrj continue;
1973*fae548d3Szrj
1974*fae548d3Szrj if (ent->size == 4)
1975*fae548d3Szrj {
1976*fae548d3Szrj /* Any terminating FDE must be at the end of the section. */
1977*fae548d3Szrj BFD_ASSERT (ent == last_ent - 1);
1978*fae548d3Szrj continue;
1979*fae548d3Szrj }
1980*fae548d3Szrj
1981*fae548d3Szrj buf = contents + ent->new_offset;
1982*fae548d3Szrj end = buf + ent->size;
1983*fae548d3Szrj new_size = next_cie_fde_offset (ent, last_ent, sec) - ent->new_offset;
1984*fae548d3Szrj
1985*fae548d3Szrj /* Update the size. It may be shrinked. */
1986*fae548d3Szrj bfd_put_32 (abfd, new_size - 4, buf);
1987*fae548d3Szrj
1988*fae548d3Szrj /* Filling the extra bytes with DW_CFA_nops. */
1989*fae548d3Szrj if (new_size != ent->size)
1990*fae548d3Szrj memset (end, 0, new_size - ent->size);
1991*fae548d3Szrj
1992*fae548d3Szrj if (ent->cie)
1993*fae548d3Szrj {
1994*fae548d3Szrj /* CIE */
1995*fae548d3Szrj if (ent->make_relative
1996*fae548d3Szrj || ent->u.cie.make_lsda_relative
1997*fae548d3Szrj || ent->u.cie.per_encoding_relative)
1998*fae548d3Szrj {
1999*fae548d3Szrj char *aug;
2000*fae548d3Szrj unsigned int version, action, extra_string, extra_data;
2001*fae548d3Szrj unsigned int per_width, per_encoding;
2002*fae548d3Szrj
2003*fae548d3Szrj /* Need to find 'R' or 'L' augmentation's argument and modify
2004*fae548d3Szrj DW_EH_PE_* value. */
2005*fae548d3Szrj action = ((ent->make_relative ? 1 : 0)
2006*fae548d3Szrj | (ent->u.cie.make_lsda_relative ? 2 : 0)
2007*fae548d3Szrj | (ent->u.cie.per_encoding_relative ? 4 : 0));
2008*fae548d3Szrj extra_string = extra_augmentation_string_bytes (ent);
2009*fae548d3Szrj extra_data = extra_augmentation_data_bytes (ent);
2010*fae548d3Szrj
2011*fae548d3Szrj /* Skip length, id. */
2012*fae548d3Szrj buf += 8;
2013*fae548d3Szrj version = *buf++;
2014*fae548d3Szrj aug = (char *) buf;
2015*fae548d3Szrj buf += strlen (aug) + 1;
2016*fae548d3Szrj skip_leb128 (&buf, end);
2017*fae548d3Szrj skip_leb128 (&buf, end);
2018*fae548d3Szrj if (version == 1)
2019*fae548d3Szrj skip_bytes (&buf, end, 1);
2020*fae548d3Szrj else
2021*fae548d3Szrj skip_leb128 (&buf, end);
2022*fae548d3Szrj if (*aug == 'z')
2023*fae548d3Szrj {
2024*fae548d3Szrj /* The uleb128 will always be a single byte for the kind
2025*fae548d3Szrj of augmentation strings that we're prepared to handle. */
2026*fae548d3Szrj *buf++ += extra_data;
2027*fae548d3Szrj aug++;
2028*fae548d3Szrj }
2029*fae548d3Szrj
2030*fae548d3Szrj /* Make room for the new augmentation string and data bytes. */
2031*fae548d3Szrj memmove (buf + extra_string + extra_data, buf, end - buf);
2032*fae548d3Szrj memmove (aug + extra_string, aug, buf - (bfd_byte *) aug);
2033*fae548d3Szrj buf += extra_string;
2034*fae548d3Szrj end += extra_string + extra_data;
2035*fae548d3Szrj
2036*fae548d3Szrj if (ent->add_augmentation_size)
2037*fae548d3Szrj {
2038*fae548d3Szrj *aug++ = 'z';
2039*fae548d3Szrj *buf++ = extra_data - 1;
2040*fae548d3Szrj }
2041*fae548d3Szrj if (ent->u.cie.add_fde_encoding)
2042*fae548d3Szrj {
2043*fae548d3Szrj BFD_ASSERT (action & 1);
2044*fae548d3Szrj *aug++ = 'R';
2045*fae548d3Szrj *buf++ = make_pc_relative (DW_EH_PE_absptr, ptr_size);
2046*fae548d3Szrj action &= ~1;
2047*fae548d3Szrj }
2048*fae548d3Szrj
2049*fae548d3Szrj while (action)
2050*fae548d3Szrj switch (*aug++)
2051*fae548d3Szrj {
2052*fae548d3Szrj case 'L':
2053*fae548d3Szrj if (action & 2)
2054*fae548d3Szrj {
2055*fae548d3Szrj BFD_ASSERT (*buf == ent->lsda_encoding);
2056*fae548d3Szrj *buf = make_pc_relative (*buf, ptr_size);
2057*fae548d3Szrj action &= ~2;
2058*fae548d3Szrj }
2059*fae548d3Szrj buf++;
2060*fae548d3Szrj break;
2061*fae548d3Szrj case 'P':
2062*fae548d3Szrj if (ent->u.cie.make_per_encoding_relative)
2063*fae548d3Szrj *buf = make_pc_relative (*buf, ptr_size);
2064*fae548d3Szrj per_encoding = *buf++;
2065*fae548d3Szrj per_width = get_DW_EH_PE_width (per_encoding, ptr_size);
2066*fae548d3Szrj BFD_ASSERT (per_width != 0);
2067*fae548d3Szrj BFD_ASSERT (((per_encoding & 0x70) == DW_EH_PE_pcrel)
2068*fae548d3Szrj == ent->u.cie.per_encoding_relative);
2069*fae548d3Szrj if ((per_encoding & 0x70) == DW_EH_PE_aligned)
2070*fae548d3Szrj buf = (contents
2071*fae548d3Szrj + ((buf - contents + per_width - 1)
2072*fae548d3Szrj & ~((bfd_size_type) per_width - 1)));
2073*fae548d3Szrj if (action & 4)
2074*fae548d3Szrj {
2075*fae548d3Szrj bfd_vma val;
2076*fae548d3Szrj
2077*fae548d3Szrj val = read_value (abfd, buf, per_width,
2078*fae548d3Szrj get_DW_EH_PE_signed (per_encoding));
2079*fae548d3Szrj if (ent->u.cie.make_per_encoding_relative)
2080*fae548d3Szrj val -= (sec->output_section->vma
2081*fae548d3Szrj + sec->output_offset
2082*fae548d3Szrj + (buf - contents));
2083*fae548d3Szrj else
2084*fae548d3Szrj {
2085*fae548d3Szrj val += (bfd_vma) ent->offset - ent->new_offset;
2086*fae548d3Szrj val -= extra_string + extra_data;
2087*fae548d3Szrj }
2088*fae548d3Szrj write_value (abfd, buf, val, per_width);
2089*fae548d3Szrj action &= ~4;
2090*fae548d3Szrj }
2091*fae548d3Szrj buf += per_width;
2092*fae548d3Szrj break;
2093*fae548d3Szrj case 'R':
2094*fae548d3Szrj if (action & 1)
2095*fae548d3Szrj {
2096*fae548d3Szrj BFD_ASSERT (*buf == ent->fde_encoding);
2097*fae548d3Szrj *buf = make_pc_relative (*buf, ptr_size);
2098*fae548d3Szrj action &= ~1;
2099*fae548d3Szrj }
2100*fae548d3Szrj buf++;
2101*fae548d3Szrj break;
2102*fae548d3Szrj case 'S':
2103*fae548d3Szrj break;
2104*fae548d3Szrj default:
2105*fae548d3Szrj BFD_FAIL ();
2106*fae548d3Szrj }
2107*fae548d3Szrj }
2108*fae548d3Szrj }
2109*fae548d3Szrj else
2110*fae548d3Szrj {
2111*fae548d3Szrj /* FDE */
2112*fae548d3Szrj bfd_vma value, address;
2113*fae548d3Szrj unsigned int width;
2114*fae548d3Szrj bfd_byte *start;
2115*fae548d3Szrj struct eh_cie_fde *cie;
2116*fae548d3Szrj
2117*fae548d3Szrj /* Skip length. */
2118*fae548d3Szrj cie = ent->u.fde.cie_inf;
2119*fae548d3Szrj buf += 4;
2120*fae548d3Szrj value = ((ent->new_offset + sec->output_offset + 4)
2121*fae548d3Szrj - (cie->new_offset + cie->u.cie.u.sec->output_offset));
2122*fae548d3Szrj bfd_put_32 (abfd, value, buf);
2123*fae548d3Szrj if (bfd_link_relocatable (info))
2124*fae548d3Szrj continue;
2125*fae548d3Szrj buf += 4;
2126*fae548d3Szrj width = get_DW_EH_PE_width (ent->fde_encoding, ptr_size);
2127*fae548d3Szrj value = read_value (abfd, buf, width,
2128*fae548d3Szrj get_DW_EH_PE_signed (ent->fde_encoding));
2129*fae548d3Szrj address = value;
2130*fae548d3Szrj if (value)
2131*fae548d3Szrj {
2132*fae548d3Szrj switch (ent->fde_encoding & 0x70)
2133*fae548d3Szrj {
2134*fae548d3Szrj case DW_EH_PE_textrel:
2135*fae548d3Szrj BFD_ASSERT (hdr_info == NULL);
2136*fae548d3Szrj break;
2137*fae548d3Szrj case DW_EH_PE_datarel:
2138*fae548d3Szrj {
2139*fae548d3Szrj switch (abfd->arch_info->arch)
2140*fae548d3Szrj {
2141*fae548d3Szrj case bfd_arch_ia64:
2142*fae548d3Szrj BFD_ASSERT (elf_gp (abfd) != 0);
2143*fae548d3Szrj address += elf_gp (abfd);
2144*fae548d3Szrj break;
2145*fae548d3Szrj default:
2146*fae548d3Szrj _bfd_error_handler
2147*fae548d3Szrj (_("DW_EH_PE_datarel unspecified"
2148*fae548d3Szrj " for this architecture"));
2149*fae548d3Szrj /* Fall thru */
2150*fae548d3Szrj case bfd_arch_frv:
2151*fae548d3Szrj case bfd_arch_i386:
2152*fae548d3Szrj BFD_ASSERT (htab->hgot != NULL
2153*fae548d3Szrj && ((htab->hgot->root.type
2154*fae548d3Szrj == bfd_link_hash_defined)
2155*fae548d3Szrj || (htab->hgot->root.type
2156*fae548d3Szrj == bfd_link_hash_defweak)));
2157*fae548d3Szrj address
2158*fae548d3Szrj += (htab->hgot->root.u.def.value
2159*fae548d3Szrj + htab->hgot->root.u.def.section->output_offset
2160*fae548d3Szrj + (htab->hgot->root.u.def.section->output_section
2161*fae548d3Szrj ->vma));
2162*fae548d3Szrj break;
2163*fae548d3Szrj }
2164*fae548d3Szrj }
2165*fae548d3Szrj break;
2166*fae548d3Szrj case DW_EH_PE_pcrel:
2167*fae548d3Szrj value += (bfd_vma) ent->offset - ent->new_offset;
2168*fae548d3Szrj address += (sec->output_section->vma
2169*fae548d3Szrj + sec->output_offset
2170*fae548d3Szrj + ent->offset + 8);
2171*fae548d3Szrj break;
2172*fae548d3Szrj }
2173*fae548d3Szrj if (ent->make_relative)
2174*fae548d3Szrj value -= (sec->output_section->vma
2175*fae548d3Szrj + sec->output_offset
2176*fae548d3Szrj + ent->new_offset + 8);
2177*fae548d3Szrj write_value (abfd, buf, value, width);
2178*fae548d3Szrj }
2179*fae548d3Szrj
2180*fae548d3Szrj start = buf;
2181*fae548d3Szrj
2182*fae548d3Szrj if (hdr_info)
2183*fae548d3Szrj {
2184*fae548d3Szrj /* The address calculation may overflow, giving us a
2185*fae548d3Szrj value greater than 4G on a 32-bit target when
2186*fae548d3Szrj dwarf_vma is 64-bit. */
2187*fae548d3Szrj if (sizeof (address) > 4 && ptr_size == 4)
2188*fae548d3Szrj address &= 0xffffffff;
2189*fae548d3Szrj hdr_info->u.dwarf.array[hdr_info->array_count].initial_loc
2190*fae548d3Szrj = address;
2191*fae548d3Szrj hdr_info->u.dwarf.array[hdr_info->array_count].range
2192*fae548d3Szrj = read_value (abfd, buf + width, width, FALSE);
2193*fae548d3Szrj hdr_info->u.dwarf.array[hdr_info->array_count++].fde
2194*fae548d3Szrj = (sec->output_section->vma
2195*fae548d3Szrj + sec->output_offset
2196*fae548d3Szrj + ent->new_offset);
2197*fae548d3Szrj }
2198*fae548d3Szrj
2199*fae548d3Szrj if ((ent->lsda_encoding & 0x70) == DW_EH_PE_pcrel
2200*fae548d3Szrj || cie->u.cie.make_lsda_relative)
2201*fae548d3Szrj {
2202*fae548d3Szrj buf += ent->lsda_offset;
2203*fae548d3Szrj width = get_DW_EH_PE_width (ent->lsda_encoding, ptr_size);
2204*fae548d3Szrj value = read_value (abfd, buf, width,
2205*fae548d3Szrj get_DW_EH_PE_signed (ent->lsda_encoding));
2206*fae548d3Szrj if (value)
2207*fae548d3Szrj {
2208*fae548d3Szrj if ((ent->lsda_encoding & 0x70) == DW_EH_PE_pcrel)
2209*fae548d3Szrj value += (bfd_vma) ent->offset - ent->new_offset;
2210*fae548d3Szrj else if (cie->u.cie.make_lsda_relative)
2211*fae548d3Szrj value -= (sec->output_section->vma
2212*fae548d3Szrj + sec->output_offset
2213*fae548d3Szrj + ent->new_offset + 8 + ent->lsda_offset);
2214*fae548d3Szrj write_value (abfd, buf, value, width);
2215*fae548d3Szrj }
2216*fae548d3Szrj }
2217*fae548d3Szrj else if (ent->add_augmentation_size)
2218*fae548d3Szrj {
2219*fae548d3Szrj /* Skip the PC and length and insert a zero byte for the
2220*fae548d3Szrj augmentation size. */
2221*fae548d3Szrj buf += width * 2;
2222*fae548d3Szrj memmove (buf + 1, buf, end - buf);
2223*fae548d3Szrj *buf = 0;
2224*fae548d3Szrj }
2225*fae548d3Szrj
2226*fae548d3Szrj if (ent->set_loc)
2227*fae548d3Szrj {
2228*fae548d3Szrj /* Adjust DW_CFA_set_loc. */
2229*fae548d3Szrj unsigned int cnt;
2230*fae548d3Szrj bfd_vma new_offset;
2231*fae548d3Szrj
2232*fae548d3Szrj width = get_DW_EH_PE_width (ent->fde_encoding, ptr_size);
2233*fae548d3Szrj new_offset = ent->new_offset + 8
2234*fae548d3Szrj + extra_augmentation_string_bytes (ent)
2235*fae548d3Szrj + extra_augmentation_data_bytes (ent);
2236*fae548d3Szrj
2237*fae548d3Szrj for (cnt = 1; cnt <= ent->set_loc[0]; cnt++)
2238*fae548d3Szrj {
2239*fae548d3Szrj buf = start + ent->set_loc[cnt];
2240*fae548d3Szrj
2241*fae548d3Szrj value = read_value (abfd, buf, width,
2242*fae548d3Szrj get_DW_EH_PE_signed (ent->fde_encoding));
2243*fae548d3Szrj if (!value)
2244*fae548d3Szrj continue;
2245*fae548d3Szrj
2246*fae548d3Szrj if ((ent->fde_encoding & 0x70) == DW_EH_PE_pcrel)
2247*fae548d3Szrj value += (bfd_vma) ent->offset + 8 - new_offset;
2248*fae548d3Szrj if (ent->make_relative)
2249*fae548d3Szrj value -= (sec->output_section->vma
2250*fae548d3Szrj + sec->output_offset
2251*fae548d3Szrj + new_offset + ent->set_loc[cnt]);
2252*fae548d3Szrj write_value (abfd, buf, value, width);
2253*fae548d3Szrj }
2254*fae548d3Szrj }
2255*fae548d3Szrj }
2256*fae548d3Szrj }
2257*fae548d3Szrj
2258*fae548d3Szrj /* FIXME: octets_per_byte. */
2259*fae548d3Szrj return bfd_set_section_contents (abfd, sec->output_section,
2260*fae548d3Szrj contents, (file_ptr) sec->output_offset,
2261*fae548d3Szrj sec->size);
2262*fae548d3Szrj }
2263*fae548d3Szrj
2264*fae548d3Szrj /* Helper function used to sort .eh_frame_hdr search table by increasing
2265*fae548d3Szrj VMA of FDE initial location. */
2266*fae548d3Szrj
2267*fae548d3Szrj static int
vma_compare(const void * a,const void * b)2268*fae548d3Szrj vma_compare (const void *a, const void *b)
2269*fae548d3Szrj {
2270*fae548d3Szrj const struct eh_frame_array_ent *p = (const struct eh_frame_array_ent *) a;
2271*fae548d3Szrj const struct eh_frame_array_ent *q = (const struct eh_frame_array_ent *) b;
2272*fae548d3Szrj if (p->initial_loc > q->initial_loc)
2273*fae548d3Szrj return 1;
2274*fae548d3Szrj if (p->initial_loc < q->initial_loc)
2275*fae548d3Szrj return -1;
2276*fae548d3Szrj if (p->range > q->range)
2277*fae548d3Szrj return 1;
2278*fae548d3Szrj if (p->range < q->range)
2279*fae548d3Szrj return -1;
2280*fae548d3Szrj return 0;
2281*fae548d3Szrj }
2282*fae548d3Szrj
2283*fae548d3Szrj /* Reorder .eh_frame_entry sections to match the associated text sections.
2284*fae548d3Szrj This routine is called during the final linking step, just before writing
2285*fae548d3Szrj the contents. At this stage, sections in the eh_frame_hdr_info are already
2286*fae548d3Szrj sorted in order of increasing text section address and so we simply need
2287*fae548d3Szrj to make the .eh_frame_entrys follow that same order. Note that it is
2288*fae548d3Szrj invalid for a linker script to try to force a particular order of
2289*fae548d3Szrj .eh_frame_entry sections. */
2290*fae548d3Szrj
2291*fae548d3Szrj bfd_boolean
_bfd_elf_fixup_eh_frame_hdr(struct bfd_link_info * info)2292*fae548d3Szrj _bfd_elf_fixup_eh_frame_hdr (struct bfd_link_info *info)
2293*fae548d3Szrj {
2294*fae548d3Szrj asection *sec = NULL;
2295*fae548d3Szrj asection *osec;
2296*fae548d3Szrj struct eh_frame_hdr_info *hdr_info;
2297*fae548d3Szrj unsigned int i;
2298*fae548d3Szrj bfd_vma offset;
2299*fae548d3Szrj struct bfd_link_order *p;
2300*fae548d3Szrj
2301*fae548d3Szrj hdr_info = &elf_hash_table (info)->eh_info;
2302*fae548d3Szrj
2303*fae548d3Szrj if (hdr_info->hdr_sec == NULL
2304*fae548d3Szrj || info->eh_frame_hdr_type != COMPACT_EH_HDR
2305*fae548d3Szrj || hdr_info->array_count == 0)
2306*fae548d3Szrj return TRUE;
2307*fae548d3Szrj
2308*fae548d3Szrj /* Change section output offsets to be in text section order. */
2309*fae548d3Szrj offset = 8;
2310*fae548d3Szrj osec = hdr_info->u.compact.entries[0]->output_section;
2311*fae548d3Szrj for (i = 0; i < hdr_info->array_count; i++)
2312*fae548d3Szrj {
2313*fae548d3Szrj sec = hdr_info->u.compact.entries[i];
2314*fae548d3Szrj if (sec->output_section != osec)
2315*fae548d3Szrj {
2316*fae548d3Szrj _bfd_error_handler
2317*fae548d3Szrj (_("invalid output section for .eh_frame_entry: %pA"),
2318*fae548d3Szrj sec->output_section);
2319*fae548d3Szrj return FALSE;
2320*fae548d3Szrj }
2321*fae548d3Szrj sec->output_offset = offset;
2322*fae548d3Szrj offset += sec->size;
2323*fae548d3Szrj }
2324*fae548d3Szrj
2325*fae548d3Szrj
2326*fae548d3Szrj /* Fix the link_order to match. */
2327*fae548d3Szrj for (p = sec->output_section->map_head.link_order; p != NULL; p = p->next)
2328*fae548d3Szrj {
2329*fae548d3Szrj if (p->type != bfd_indirect_link_order)
2330*fae548d3Szrj abort();
2331*fae548d3Szrj
2332*fae548d3Szrj p->offset = p->u.indirect.section->output_offset;
2333*fae548d3Szrj if (p->next != NULL)
2334*fae548d3Szrj i--;
2335*fae548d3Szrj }
2336*fae548d3Szrj
2337*fae548d3Szrj if (i != 0)
2338*fae548d3Szrj {
2339*fae548d3Szrj _bfd_error_handler
2340*fae548d3Szrj (_("invalid contents in %pA section"), osec);
2341*fae548d3Szrj return FALSE;
2342*fae548d3Szrj }
2343*fae548d3Szrj
2344*fae548d3Szrj return TRUE;
2345*fae548d3Szrj }
2346*fae548d3Szrj
2347*fae548d3Szrj /* The .eh_frame_hdr format for Compact EH frames:
2348*fae548d3Szrj ubyte version (2)
2349*fae548d3Szrj ubyte eh_ref_enc (DW_EH_PE_* encoding of typinfo references)
2350*fae548d3Szrj uint32_t count (Number of entries in table)
2351*fae548d3Szrj [array from .eh_frame_entry sections] */
2352*fae548d3Szrj
2353*fae548d3Szrj static bfd_boolean
write_compact_eh_frame_hdr(bfd * abfd,struct bfd_link_info * info)2354*fae548d3Szrj write_compact_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info)
2355*fae548d3Szrj {
2356*fae548d3Szrj struct elf_link_hash_table *htab;
2357*fae548d3Szrj struct eh_frame_hdr_info *hdr_info;
2358*fae548d3Szrj asection *sec;
2359*fae548d3Szrj const struct elf_backend_data *bed;
2360*fae548d3Szrj bfd_vma count;
2361*fae548d3Szrj bfd_byte contents[8];
2362*fae548d3Szrj unsigned int i;
2363*fae548d3Szrj
2364*fae548d3Szrj htab = elf_hash_table (info);
2365*fae548d3Szrj hdr_info = &htab->eh_info;
2366*fae548d3Szrj sec = hdr_info->hdr_sec;
2367*fae548d3Szrj
2368*fae548d3Szrj if (sec->size != 8)
2369*fae548d3Szrj abort();
2370*fae548d3Szrj
2371*fae548d3Szrj for (i = 0; i < sizeof (contents); i++)
2372*fae548d3Szrj contents[i] = 0;
2373*fae548d3Szrj
2374*fae548d3Szrj contents[0] = COMPACT_EH_HDR;
2375*fae548d3Szrj bed = get_elf_backend_data (abfd);
2376*fae548d3Szrj
2377*fae548d3Szrj BFD_ASSERT (bed->compact_eh_encoding);
2378*fae548d3Szrj contents[1] = (*bed->compact_eh_encoding) (info);
2379*fae548d3Szrj
2380*fae548d3Szrj count = (sec->output_section->size - 8) / 8;
2381*fae548d3Szrj bfd_put_32 (abfd, count, contents + 4);
2382*fae548d3Szrj return bfd_set_section_contents (abfd, sec->output_section, contents,
2383*fae548d3Szrj (file_ptr) sec->output_offset, sec->size);
2384*fae548d3Szrj }
2385*fae548d3Szrj
2386*fae548d3Szrj /* The .eh_frame_hdr format for DWARF frames:
2387*fae548d3Szrj
2388*fae548d3Szrj ubyte version (currently 1)
2389*fae548d3Szrj ubyte eh_frame_ptr_enc (DW_EH_PE_* encoding of pointer to start of
2390*fae548d3Szrj .eh_frame section)
2391*fae548d3Szrj ubyte fde_count_enc (DW_EH_PE_* encoding of total FDE count
2392*fae548d3Szrj number (or DW_EH_PE_omit if there is no
2393*fae548d3Szrj binary search table computed))
2394*fae548d3Szrj ubyte table_enc (DW_EH_PE_* encoding of binary search table,
2395*fae548d3Szrj or DW_EH_PE_omit if not present.
2396*fae548d3Szrj DW_EH_PE_datarel is using address of
2397*fae548d3Szrj .eh_frame_hdr section start as base)
2398*fae548d3Szrj [encoded] eh_frame_ptr (pointer to start of .eh_frame section)
2399*fae548d3Szrj optionally followed by:
2400*fae548d3Szrj [encoded] fde_count (total number of FDEs in .eh_frame section)
2401*fae548d3Szrj fde_count x [encoded] initial_loc, fde
2402*fae548d3Szrj (array of encoded pairs containing
2403*fae548d3Szrj FDE initial_location field and FDE address,
2404*fae548d3Szrj sorted by increasing initial_loc). */
2405*fae548d3Szrj
2406*fae548d3Szrj static bfd_boolean
write_dwarf_eh_frame_hdr(bfd * abfd,struct bfd_link_info * info)2407*fae548d3Szrj write_dwarf_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info)
2408*fae548d3Szrj {
2409*fae548d3Szrj struct elf_link_hash_table *htab;
2410*fae548d3Szrj struct eh_frame_hdr_info *hdr_info;
2411*fae548d3Szrj asection *sec;
2412*fae548d3Szrj bfd_boolean retval = TRUE;
2413*fae548d3Szrj
2414*fae548d3Szrj htab = elf_hash_table (info);
2415*fae548d3Szrj hdr_info = &htab->eh_info;
2416*fae548d3Szrj sec = hdr_info->hdr_sec;
2417*fae548d3Szrj bfd_byte *contents;
2418*fae548d3Szrj asection *eh_frame_sec;
2419*fae548d3Szrj bfd_size_type size;
2420*fae548d3Szrj bfd_vma encoded_eh_frame;
2421*fae548d3Szrj
2422*fae548d3Szrj size = EH_FRAME_HDR_SIZE;
2423*fae548d3Szrj if (hdr_info->u.dwarf.array
2424*fae548d3Szrj && hdr_info->array_count == hdr_info->u.dwarf.fde_count)
2425*fae548d3Szrj size += 4 + hdr_info->u.dwarf.fde_count * 8;
2426*fae548d3Szrj contents = (bfd_byte *) bfd_malloc (size);
2427*fae548d3Szrj if (contents == NULL)
2428*fae548d3Szrj return FALSE;
2429*fae548d3Szrj
2430*fae548d3Szrj eh_frame_sec = bfd_get_section_by_name (abfd, ".eh_frame");
2431*fae548d3Szrj if (eh_frame_sec == NULL)
2432*fae548d3Szrj {
2433*fae548d3Szrj free (contents);
2434*fae548d3Szrj return FALSE;
2435*fae548d3Szrj }
2436*fae548d3Szrj
2437*fae548d3Szrj memset (contents, 0, EH_FRAME_HDR_SIZE);
2438*fae548d3Szrj /* Version. */
2439*fae548d3Szrj contents[0] = 1;
2440*fae548d3Szrj /* .eh_frame offset. */
2441*fae548d3Szrj contents[1] = get_elf_backend_data (abfd)->elf_backend_encode_eh_address
2442*fae548d3Szrj (abfd, info, eh_frame_sec, 0, sec, 4, &encoded_eh_frame);
2443*fae548d3Szrj
2444*fae548d3Szrj if (hdr_info->u.dwarf.array
2445*fae548d3Szrj && hdr_info->array_count == hdr_info->u.dwarf.fde_count)
2446*fae548d3Szrj {
2447*fae548d3Szrj /* FDE count encoding. */
2448*fae548d3Szrj contents[2] = DW_EH_PE_udata4;
2449*fae548d3Szrj /* Search table encoding. */
2450*fae548d3Szrj contents[3] = DW_EH_PE_datarel | DW_EH_PE_sdata4;
2451*fae548d3Szrj }
2452*fae548d3Szrj else
2453*fae548d3Szrj {
2454*fae548d3Szrj contents[2] = DW_EH_PE_omit;
2455*fae548d3Szrj contents[3] = DW_EH_PE_omit;
2456*fae548d3Szrj }
2457*fae548d3Szrj bfd_put_32 (abfd, encoded_eh_frame, contents + 4);
2458*fae548d3Szrj
2459*fae548d3Szrj if (contents[2] != DW_EH_PE_omit)
2460*fae548d3Szrj {
2461*fae548d3Szrj unsigned int i;
2462*fae548d3Szrj bfd_boolean overlap, overflow;
2463*fae548d3Szrj
2464*fae548d3Szrj bfd_put_32 (abfd, hdr_info->u.dwarf.fde_count,
2465*fae548d3Szrj contents + EH_FRAME_HDR_SIZE);
2466*fae548d3Szrj qsort (hdr_info->u.dwarf.array, hdr_info->u.dwarf.fde_count,
2467*fae548d3Szrj sizeof (*hdr_info->u.dwarf.array), vma_compare);
2468*fae548d3Szrj overlap = FALSE;
2469*fae548d3Szrj overflow = FALSE;
2470*fae548d3Szrj for (i = 0; i < hdr_info->u.dwarf.fde_count; i++)
2471*fae548d3Szrj {
2472*fae548d3Szrj bfd_vma val;
2473*fae548d3Szrj
2474*fae548d3Szrj val = hdr_info->u.dwarf.array[i].initial_loc
2475*fae548d3Szrj - sec->output_section->vma;
2476*fae548d3Szrj val = ((val & 0xffffffff) ^ 0x80000000) - 0x80000000;
2477*fae548d3Szrj if (elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64
2478*fae548d3Szrj && (hdr_info->u.dwarf.array[i].initial_loc
2479*fae548d3Szrj != sec->output_section->vma + val))
2480*fae548d3Szrj overflow = TRUE;
2481*fae548d3Szrj bfd_put_32 (abfd, val, contents + EH_FRAME_HDR_SIZE + i * 8 + 4);
2482*fae548d3Szrj val = hdr_info->u.dwarf.array[i].fde - sec->output_section->vma;
2483*fae548d3Szrj val = ((val & 0xffffffff) ^ 0x80000000) - 0x80000000;
2484*fae548d3Szrj if (elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64
2485*fae548d3Szrj && (hdr_info->u.dwarf.array[i].fde
2486*fae548d3Szrj != sec->output_section->vma + val))
2487*fae548d3Szrj overflow = TRUE;
2488*fae548d3Szrj bfd_put_32 (abfd, val, contents + EH_FRAME_HDR_SIZE + i * 8 + 8);
2489*fae548d3Szrj if (i != 0
2490*fae548d3Szrj && (hdr_info->u.dwarf.array[i].initial_loc
2491*fae548d3Szrj < (hdr_info->u.dwarf.array[i - 1].initial_loc
2492*fae548d3Szrj + hdr_info->u.dwarf.array[i - 1].range)))
2493*fae548d3Szrj overlap = TRUE;
2494*fae548d3Szrj }
2495*fae548d3Szrj if (overflow)
2496*fae548d3Szrj _bfd_error_handler (_(".eh_frame_hdr entry overflow"));
2497*fae548d3Szrj if (overlap)
2498*fae548d3Szrj _bfd_error_handler (_(".eh_frame_hdr refers to overlapping FDEs"));
2499*fae548d3Szrj if (overflow || overlap)
2500*fae548d3Szrj {
2501*fae548d3Szrj bfd_set_error (bfd_error_bad_value);
2502*fae548d3Szrj retval = FALSE;
2503*fae548d3Szrj }
2504*fae548d3Szrj }
2505*fae548d3Szrj
2506*fae548d3Szrj /* FIXME: octets_per_byte. */
2507*fae548d3Szrj if (!bfd_set_section_contents (abfd, sec->output_section, contents,
2508*fae548d3Szrj (file_ptr) sec->output_offset,
2509*fae548d3Szrj sec->size))
2510*fae548d3Szrj retval = FALSE;
2511*fae548d3Szrj free (contents);
2512*fae548d3Szrj
2513*fae548d3Szrj if (hdr_info->u.dwarf.array != NULL)
2514*fae548d3Szrj free (hdr_info->u.dwarf.array);
2515*fae548d3Szrj return retval;
2516*fae548d3Szrj }
2517*fae548d3Szrj
2518*fae548d3Szrj /* Write out .eh_frame_hdr section. This must be called after
2519*fae548d3Szrj _bfd_elf_write_section_eh_frame has been called on all input
2520*fae548d3Szrj .eh_frame sections. */
2521*fae548d3Szrj
2522*fae548d3Szrj bfd_boolean
_bfd_elf_write_section_eh_frame_hdr(bfd * abfd,struct bfd_link_info * info)2523*fae548d3Szrj _bfd_elf_write_section_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info)
2524*fae548d3Szrj {
2525*fae548d3Szrj struct elf_link_hash_table *htab;
2526*fae548d3Szrj struct eh_frame_hdr_info *hdr_info;
2527*fae548d3Szrj asection *sec;
2528*fae548d3Szrj
2529*fae548d3Szrj htab = elf_hash_table (info);
2530*fae548d3Szrj hdr_info = &htab->eh_info;
2531*fae548d3Szrj sec = hdr_info->hdr_sec;
2532*fae548d3Szrj
2533*fae548d3Szrj if (info->eh_frame_hdr_type == 0 || sec == NULL)
2534*fae548d3Szrj return TRUE;
2535*fae548d3Szrj
2536*fae548d3Szrj if (info->eh_frame_hdr_type == COMPACT_EH_HDR)
2537*fae548d3Szrj return write_compact_eh_frame_hdr (abfd, info);
2538*fae548d3Szrj else
2539*fae548d3Szrj return write_dwarf_eh_frame_hdr (abfd, info);
2540*fae548d3Szrj }
2541*fae548d3Szrj
2542*fae548d3Szrj /* Return the width of FDE addresses. This is the default implementation. */
2543*fae548d3Szrj
2544*fae548d3Szrj unsigned int
_bfd_elf_eh_frame_address_size(bfd * abfd,const asection * sec ATTRIBUTE_UNUSED)2545*fae548d3Szrj _bfd_elf_eh_frame_address_size (bfd *abfd, const asection *sec ATTRIBUTE_UNUSED)
2546*fae548d3Szrj {
2547*fae548d3Szrj return elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64 ? 8 : 4;
2548*fae548d3Szrj }
2549*fae548d3Szrj
2550*fae548d3Szrj /* Decide whether we can use a PC-relative encoding within the given
2551*fae548d3Szrj EH frame section. This is the default implementation. */
2552*fae548d3Szrj
2553*fae548d3Szrj bfd_boolean
_bfd_elf_can_make_relative(bfd * input_bfd ATTRIBUTE_UNUSED,struct bfd_link_info * info ATTRIBUTE_UNUSED,asection * eh_frame_section ATTRIBUTE_UNUSED)2554*fae548d3Szrj _bfd_elf_can_make_relative (bfd *input_bfd ATTRIBUTE_UNUSED,
2555*fae548d3Szrj struct bfd_link_info *info ATTRIBUTE_UNUSED,
2556*fae548d3Szrj asection *eh_frame_section ATTRIBUTE_UNUSED)
2557*fae548d3Szrj {
2558*fae548d3Szrj return TRUE;
2559*fae548d3Szrj }
2560*fae548d3Szrj
2561*fae548d3Szrj /* Select an encoding for the given address. Preference is given to
2562*fae548d3Szrj PC-relative addressing modes. */
2563*fae548d3Szrj
2564*fae548d3Szrj bfd_byte
_bfd_elf_encode_eh_address(bfd * abfd ATTRIBUTE_UNUSED,struct bfd_link_info * info ATTRIBUTE_UNUSED,asection * osec,bfd_vma offset,asection * loc_sec,bfd_vma loc_offset,bfd_vma * encoded)2565*fae548d3Szrj _bfd_elf_encode_eh_address (bfd *abfd ATTRIBUTE_UNUSED,
2566*fae548d3Szrj struct bfd_link_info *info ATTRIBUTE_UNUSED,
2567*fae548d3Szrj asection *osec, bfd_vma offset,
2568*fae548d3Szrj asection *loc_sec, bfd_vma loc_offset,
2569*fae548d3Szrj bfd_vma *encoded)
2570*fae548d3Szrj {
2571*fae548d3Szrj *encoded = osec->vma + offset -
2572*fae548d3Szrj (loc_sec->output_section->vma + loc_sec->output_offset + loc_offset);
2573*fae548d3Szrj return DW_EH_PE_pcrel | DW_EH_PE_sdata4;
2574*fae548d3Szrj }
2575