OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gdb-6.8/] [bfd/] [elf-eh-frame.c] - Blame information for rev 840

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 24 jeremybenn
/* .eh_frame section optimization.
2 225 jeremybenn
   Copyright 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
3 24 jeremybenn
   Free Software Foundation, Inc.
4
   Written by Jakub Jelinek <jakub@redhat.com>.
5
 
6
   This file is part of BFD, the Binary File Descriptor library.
7
 
8
   This program is free software; you can redistribute it and/or modify
9
   it under the terms of the GNU General Public License as published by
10
   the Free Software Foundation; either version 3 of the License, or
11
   (at your option) any later version.
12
 
13
   This program is distributed in the hope that it will be useful,
14
   but WITHOUT ANY WARRANTY; without even the implied warranty of
15
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16
   GNU General Public License for more details.
17
 
18
   You should have received a copy of the GNU General Public License
19
   along with this program; if not, write to the Free Software
20
   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21
   MA 02110-1301, USA.  */
22
 
23
#include "sysdep.h"
24
#include "bfd.h"
25
#include "libbfd.h"
26
#include "elf-bfd.h"
27 225 jeremybenn
#include "dwarf2.h"
28 24 jeremybenn
 
29
#define EH_FRAME_HDR_SIZE 8
30
 
31
struct cie
32
{
33
  unsigned int length;
34
  unsigned int hash;
35
  unsigned char version;
36
  unsigned char local_personality;
37
  char augmentation[20];
38
  bfd_vma code_align;
39
  bfd_signed_vma data_align;
40
  bfd_vma ra_column;
41
  bfd_vma augmentation_size;
42
  union {
43
    struct elf_link_hash_entry *h;
44
    bfd_vma val;
45
    unsigned int reloc_index;
46
  } personality;
47
  asection *output_sec;
48
  struct eh_cie_fde *cie_inf;
49
  unsigned char per_encoding;
50
  unsigned char lsda_encoding;
51
  unsigned char fde_encoding;
52
  unsigned char initial_insn_length;
53
  unsigned char can_make_lsda_relative;
54
  unsigned char initial_instructions[50];
55
};
56
 
57
 
58
 
59
/* If *ITER hasn't reached END yet, read the next byte into *RESULT and
60
   move onto the next byte.  Return true on success.  */
61
 
62
static inline bfd_boolean
63
read_byte (bfd_byte **iter, bfd_byte *end, unsigned char *result)
64
{
65
  if (*iter >= end)
66
    return FALSE;
67
  *result = *((*iter)++);
68
  return TRUE;
69
}
70
 
71
/* Move *ITER over LENGTH bytes, or up to END, whichever is closer.
72
   Return true it was possible to move LENGTH bytes.  */
73
 
74
static inline bfd_boolean
75
skip_bytes (bfd_byte **iter, bfd_byte *end, bfd_size_type length)
76
{
77
  if ((bfd_size_type) (end - *iter) < length)
78
    {
79
      *iter = end;
80
      return FALSE;
81
    }
82
  *iter += length;
83
  return TRUE;
84
}
85
 
86
/* Move *ITER over an leb128, stopping at END.  Return true if the end
87
   of the leb128 was found.  */
88
 
89
static bfd_boolean
90
skip_leb128 (bfd_byte **iter, bfd_byte *end)
91
{
92
  unsigned char byte;
93
  do
94
    if (!read_byte (iter, end, &byte))
95
      return FALSE;
96
  while (byte & 0x80);
97
  return TRUE;
98
}
99
 
100
/* Like skip_leb128, but treat the leb128 as an unsigned value and
101
   store it in *VALUE.  */
102
 
103
static bfd_boolean
104
read_uleb128 (bfd_byte **iter, bfd_byte *end, bfd_vma *value)
105
{
106
  bfd_byte *start, *p;
107
 
108
  start = *iter;
109
  if (!skip_leb128 (iter, end))
110
    return FALSE;
111
 
112
  p = *iter;
113
  *value = *--p;
114
  while (p > start)
115
    *value = (*value << 7) | (*--p & 0x7f);
116
 
117
  return TRUE;
118
}
119
 
120
/* Like read_uleb128, but for signed values.  */
121
 
122
static bfd_boolean
123
read_sleb128 (bfd_byte **iter, bfd_byte *end, bfd_signed_vma *value)
124
{
125
  bfd_byte *start, *p;
126
 
127
  start = *iter;
128
  if (!skip_leb128 (iter, end))
129
    return FALSE;
130
 
131
  p = *iter;
132
  *value = ((*--p & 0x7f) ^ 0x40) - 0x40;
133
  while (p > start)
134
    *value = (*value << 7) | (*--p & 0x7f);
135
 
136
  return TRUE;
137
}
138
 
139
/* Return 0 if either encoding is variable width, or not yet known to bfd.  */
140
 
141
static
142
int get_DW_EH_PE_width (int encoding, int ptr_size)
143
{
144
  /* DW_EH_PE_ values of 0x60 and 0x70 weren't defined at the time .eh_frame
145
     was added to bfd.  */
146
  if ((encoding & 0x60) == 0x60)
147
    return 0;
148
 
149
  switch (encoding & 7)
150
    {
151
    case DW_EH_PE_udata2: return 2;
152
    case DW_EH_PE_udata4: return 4;
153
    case DW_EH_PE_udata8: return 8;
154
    case DW_EH_PE_absptr: return ptr_size;
155
    default:
156
      break;
157
    }
158
 
159
  return 0;
160
}
161
 
162
#define get_DW_EH_PE_signed(encoding) (((encoding) & DW_EH_PE_signed) != 0)
163
 
164
/* Read a width sized value from memory.  */
165
 
166
static bfd_vma
167
read_value (bfd *abfd, bfd_byte *buf, int width, int is_signed)
168
{
169
  bfd_vma value;
170
 
171
  switch (width)
172
    {
173
    case 2:
174
      if (is_signed)
175
        value = bfd_get_signed_16 (abfd, buf);
176
      else
177
        value = bfd_get_16 (abfd, buf);
178
      break;
179
    case 4:
180
      if (is_signed)
181
        value = bfd_get_signed_32 (abfd, buf);
182
      else
183
        value = bfd_get_32 (abfd, buf);
184
      break;
185
    case 8:
186
      if (is_signed)
187
        value = bfd_get_signed_64 (abfd, buf);
188
      else
189
        value = bfd_get_64 (abfd, buf);
190
      break;
191
    default:
192
      BFD_FAIL ();
193
      return 0;
194
    }
195
 
196
  return value;
197
}
198
 
199
/* Store a width sized value to memory.  */
200
 
201
static void
202
write_value (bfd *abfd, bfd_byte *buf, bfd_vma value, int width)
203
{
204
  switch (width)
205
    {
206
    case 2: bfd_put_16 (abfd, value, buf); break;
207
    case 4: bfd_put_32 (abfd, value, buf); break;
208
    case 8: bfd_put_64 (abfd, value, buf); break;
209
    default: BFD_FAIL ();
210
    }
211
}
212
 
213
/* Return one if C1 and C2 CIEs can be merged.  */
214
 
215
static int
216
cie_eq (const void *e1, const void *e2)
217
{
218 225 jeremybenn
  const struct cie *c1 = (const struct cie *) e1;
219
  const struct cie *c2 = (const struct cie *) e2;
220 24 jeremybenn
 
221
  if (c1->hash == c2->hash
222
      && c1->length == c2->length
223
      && c1->version == c2->version
224
      && c1->local_personality == c2->local_personality
225
      && strcmp (c1->augmentation, c2->augmentation) == 0
226
      && strcmp (c1->augmentation, "eh") != 0
227
      && c1->code_align == c2->code_align
228
      && c1->data_align == c2->data_align
229
      && c1->ra_column == c2->ra_column
230
      && c1->augmentation_size == c2->augmentation_size
231
      && memcmp (&c1->personality, &c2->personality,
232
                 sizeof (c1->personality)) == 0
233
      && c1->output_sec == c2->output_sec
234
      && c1->per_encoding == c2->per_encoding
235
      && c1->lsda_encoding == c2->lsda_encoding
236
      && c1->fde_encoding == c2->fde_encoding
237
      && c1->initial_insn_length == c2->initial_insn_length
238
      && memcmp (c1->initial_instructions,
239
                 c2->initial_instructions,
240
                 c1->initial_insn_length) == 0)
241
    return 1;
242
 
243
  return 0;
244
}
245
 
246
static hashval_t
247
cie_hash (const void *e)
248
{
249 225 jeremybenn
  const struct cie *c = (const struct cie *) e;
250 24 jeremybenn
  return c->hash;
251
}
252
 
253
static hashval_t
254
cie_compute_hash (struct cie *c)
255
{
256
  hashval_t h = 0;
257
  h = iterative_hash_object (c->length, h);
258
  h = iterative_hash_object (c->version, h);
259
  h = iterative_hash (c->augmentation, strlen (c->augmentation) + 1, h);
260
  h = iterative_hash_object (c->code_align, h);
261
  h = iterative_hash_object (c->data_align, h);
262
  h = iterative_hash_object (c->ra_column, h);
263
  h = iterative_hash_object (c->augmentation_size, h);
264
  h = iterative_hash_object (c->personality, h);
265
  h = iterative_hash_object (c->output_sec, h);
266
  h = iterative_hash_object (c->per_encoding, h);
267
  h = iterative_hash_object (c->lsda_encoding, h);
268
  h = iterative_hash_object (c->fde_encoding, h);
269
  h = iterative_hash_object (c->initial_insn_length, h);
270
  h = iterative_hash (c->initial_instructions, c->initial_insn_length, h);
271
  c->hash = h;
272
  return h;
273
}
274
 
275
/* Return the number of extra bytes that we'll be inserting into
276
   ENTRY's augmentation string.  */
277
 
278
static INLINE unsigned int
279
extra_augmentation_string_bytes (struct eh_cie_fde *entry)
280
{
281
  unsigned int size = 0;
282
  if (entry->cie)
283
    {
284
      if (entry->add_augmentation_size)
285
        size++;
286
      if (entry->u.cie.add_fde_encoding)
287
        size++;
288
    }
289
  return size;
290
}
291
 
292
/* Likewise ENTRY's augmentation data.  */
293
 
294
static INLINE unsigned int
295
extra_augmentation_data_bytes (struct eh_cie_fde *entry)
296
{
297
  unsigned int size = 0;
298
  if (entry->add_augmentation_size)
299
    size++;
300
  if (entry->cie && entry->u.cie.add_fde_encoding)
301
    size++;
302
  return size;
303
}
304
 
305
/* Return the size that ENTRY will have in the output.  ALIGNMENT is the
306
   required alignment of ENTRY in bytes.  */
307
 
308
static unsigned int
309
size_of_output_cie_fde (struct eh_cie_fde *entry, unsigned int alignment)
310
{
311
  if (entry->removed)
312
    return 0;
313
  if (entry->size == 4)
314
    return 4;
315
  return (entry->size
316
          + extra_augmentation_string_bytes (entry)
317
          + extra_augmentation_data_bytes (entry)
318
          + alignment - 1) & -alignment;
319
}
320
 
321
/* Assume that the bytes between *ITER and END are CFA instructions.
322
   Try to move *ITER past the first instruction and return true on
323
   success.  ENCODED_PTR_WIDTH gives the width of pointer entries.  */
324
 
325
static bfd_boolean
326
skip_cfa_op (bfd_byte **iter, bfd_byte *end, unsigned int encoded_ptr_width)
327
{
328
  bfd_byte op;
329
  bfd_vma length;
330
 
331
  if (!read_byte (iter, end, &op))
332
    return FALSE;
333
 
334
  switch (op & 0xc0 ? op & 0xc0 : op)
335
    {
336
    case DW_CFA_nop:
337
    case DW_CFA_advance_loc:
338
    case DW_CFA_restore:
339
    case DW_CFA_remember_state:
340
    case DW_CFA_restore_state:
341
    case DW_CFA_GNU_window_save:
342
      /* No arguments.  */
343
      return TRUE;
344
 
345
    case DW_CFA_offset:
346
    case DW_CFA_restore_extended:
347
    case DW_CFA_undefined:
348
    case DW_CFA_same_value:
349
    case DW_CFA_def_cfa_register:
350
    case DW_CFA_def_cfa_offset:
351
    case DW_CFA_def_cfa_offset_sf:
352
    case DW_CFA_GNU_args_size:
353
      /* One leb128 argument.  */
354
      return skip_leb128 (iter, end);
355
 
356
    case DW_CFA_val_offset:
357
    case DW_CFA_val_offset_sf:
358
    case DW_CFA_offset_extended:
359
    case DW_CFA_register:
360
    case DW_CFA_def_cfa:
361
    case DW_CFA_offset_extended_sf:
362
    case DW_CFA_GNU_negative_offset_extended:
363
    case DW_CFA_def_cfa_sf:
364
      /* Two leb128 arguments.  */
365
      return (skip_leb128 (iter, end)
366
              && skip_leb128 (iter, end));
367
 
368
    case DW_CFA_def_cfa_expression:
369
      /* A variable-length argument.  */
370
      return (read_uleb128 (iter, end, &length)
371
              && skip_bytes (iter, end, length));
372
 
373
    case DW_CFA_expression:
374
    case DW_CFA_val_expression:
375
      /* A leb128 followed by a variable-length argument.  */
376
      return (skip_leb128 (iter, end)
377
              && read_uleb128 (iter, end, &length)
378
              && skip_bytes (iter, end, length));
379
 
380
    case DW_CFA_set_loc:
381
      return skip_bytes (iter, end, encoded_ptr_width);
382
 
383
    case DW_CFA_advance_loc1:
384
      return skip_bytes (iter, end, 1);
385
 
386
    case DW_CFA_advance_loc2:
387
      return skip_bytes (iter, end, 2);
388
 
389
    case DW_CFA_advance_loc4:
390
      return skip_bytes (iter, end, 4);
391
 
392
    case DW_CFA_MIPS_advance_loc8:
393
      return skip_bytes (iter, end, 8);
394
 
395
    default:
396
      return FALSE;
397
    }
398
}
399
 
400
/* Try to interpret the bytes between BUF and END as CFA instructions.
401
   If every byte makes sense, return a pointer to the first DW_CFA_nop
402
   padding byte, or END if there is no padding.  Return null otherwise.
403
   ENCODED_PTR_WIDTH is as for skip_cfa_op.  */
404
 
405
static bfd_byte *
406
skip_non_nops (bfd_byte *buf, bfd_byte *end, unsigned int encoded_ptr_width,
407
               unsigned int *set_loc_count)
408
{
409
  bfd_byte *last;
410
 
411
  last = buf;
412
  while (buf < end)
413
    if (*buf == DW_CFA_nop)
414
      buf++;
415
    else
416
      {
417
        if (*buf == DW_CFA_set_loc)
418
          ++*set_loc_count;
419
        if (!skip_cfa_op (&buf, end, encoded_ptr_width))
420
          return 0;
421
        last = buf;
422
      }
423
  return last;
424
}
425
 
426
/* Called before calling _bfd_elf_parse_eh_frame on every input bfd's
427
   .eh_frame section.  */
428
 
429
void
430
_bfd_elf_begin_eh_frame_parsing (struct bfd_link_info *info)
431
{
432
  struct eh_frame_hdr_info *hdr_info;
433
 
434
  hdr_info = &elf_hash_table (info)->eh_info;
435
  hdr_info->merge_cies = !info->relocatable;
436
}
437
 
438
/* Try to parse .eh_frame section SEC, which belongs to ABFD.  Store the
439
   information in the section's sec_info field on success.  COOKIE
440
   describes the relocations in SEC.  */
441
 
442
void
443
_bfd_elf_parse_eh_frame (bfd *abfd, struct bfd_link_info *info,
444
                         asection *sec, struct elf_reloc_cookie *cookie)
445
{
446
#define REQUIRE(COND)                                   \
447
  do                                                    \
448
    if (!(COND))                                        \
449
      goto free_no_table;                               \
450
  while (0)
451
 
452
  bfd_byte *ehbuf = NULL, *buf, *end;
453
  bfd_byte *last_fde;
454
  struct eh_cie_fde *this_inf;
455
  unsigned int hdr_length, hdr_id;
456
  unsigned int cie_count;
457
  struct cie *cie, *local_cies = NULL;
458
  struct elf_link_hash_table *htab;
459
  struct eh_frame_hdr_info *hdr_info;
460
  struct eh_frame_sec_info *sec_info = NULL;
461
  unsigned int ptr_size;
462
  unsigned int num_cies;
463
  unsigned int num_entries;
464
  elf_gc_mark_hook_fn gc_mark_hook;
465
 
466
  htab = elf_hash_table (info);
467
  hdr_info = &htab->eh_info;
468
  if (hdr_info->parsed_eh_frames)
469
    return;
470
 
471
  if (sec->size == 0)
472
    {
473
      /* This file does not contain .eh_frame information.  */
474
      return;
475
    }
476
 
477
  if (bfd_is_abs_section (sec->output_section))
478
    {
479
      /* At least one of the sections is being discarded from the
480
         link, so we should just ignore them.  */
481
      return;
482
    }
483
 
484
  /* Read the frame unwind information from abfd.  */
485
 
486
  REQUIRE (bfd_malloc_and_get_section (abfd, sec, &ehbuf));
487
 
488
  if (sec->size >= 4
489
      && bfd_get_32 (abfd, ehbuf) == 0
490
      && cookie->rel == cookie->relend)
491
    {
492
      /* Empty .eh_frame section.  */
493
      free (ehbuf);
494
      return;
495
    }
496
 
497
  /* If .eh_frame section size doesn't fit into int, we cannot handle
498
     it (it would need to use 64-bit .eh_frame format anyway).  */
499
  REQUIRE (sec->size == (unsigned int) sec->size);
500
 
501
  ptr_size = (get_elf_backend_data (abfd)
502
              ->elf_backend_eh_frame_address_size (abfd, sec));
503
  REQUIRE (ptr_size != 0);
504
 
505
  /* Go through the section contents and work out how many FDEs and
506
     CIEs there are.  */
507
  buf = ehbuf;
508
  end = ehbuf + sec->size;
509
  num_cies = 0;
510
  num_entries = 0;
511
  while (buf != end)
512
    {
513
      num_entries++;
514
 
515
      /* Read the length of the entry.  */
516
      REQUIRE (skip_bytes (&buf, end, 4));
517
      hdr_length = bfd_get_32 (abfd, buf - 4);
518
 
519
      /* 64-bit .eh_frame is not supported.  */
520
      REQUIRE (hdr_length != 0xffffffff);
521
      if (hdr_length == 0)
522
        break;
523
 
524
      REQUIRE (skip_bytes (&buf, end, 4));
525
      hdr_id = bfd_get_32 (abfd, buf - 4);
526
      if (hdr_id == 0)
527
        num_cies++;
528
 
529
      REQUIRE (skip_bytes (&buf, end, hdr_length - 4));
530
    }
531
 
532 225 jeremybenn
  sec_info = (struct eh_frame_sec_info *)
533
      bfd_zmalloc (sizeof (struct eh_frame_sec_info)
534
                   + (num_entries - 1) * sizeof (struct eh_cie_fde));
535 24 jeremybenn
  REQUIRE (sec_info);
536
 
537
  /* We need to have a "struct cie" for each CIE in this section.  */
538 225 jeremybenn
  local_cies = (struct cie *) bfd_zmalloc (num_cies * sizeof (*local_cies));
539 24 jeremybenn
  REQUIRE (local_cies);
540
 
541 225 jeremybenn
  /* FIXME: octets_per_byte.  */
542 24 jeremybenn
#define ENSURE_NO_RELOCS(buf)                           \
543
  REQUIRE (!(cookie->rel < cookie->relend               \
544
             && (cookie->rel->r_offset                  \
545
                 < (bfd_size_type) ((buf) - ehbuf))     \
546
             && cookie->rel->r_info != 0))
547
 
548 225 jeremybenn
  /* FIXME: octets_per_byte.  */
549 24 jeremybenn
#define SKIP_RELOCS(buf)                                \
550
  while (cookie->rel < cookie->relend                   \
551
         && (cookie->rel->r_offset                      \
552
             < (bfd_size_type) ((buf) - ehbuf)))        \
553
    cookie->rel++
554
 
555 225 jeremybenn
  /* FIXME: octets_per_byte.  */
556 24 jeremybenn
#define GET_RELOC(buf)                                  \
557
  ((cookie->rel < cookie->relend                        \
558
    && (cookie->rel->r_offset                           \
559
        == (bfd_size_type) ((buf) - ehbuf)))            \
560
   ? cookie->rel : NULL)
561
 
562
  buf = ehbuf;
563
  cie_count = 0;
564
  gc_mark_hook = get_elf_backend_data (abfd)->gc_mark_hook;
565
  while ((bfd_size_type) (buf - ehbuf) != sec->size)
566
    {
567
      char *aug;
568
      bfd_byte *start, *insns, *insns_end;
569
      bfd_size_type length;
570
      unsigned int set_loc_count;
571
 
572
      this_inf = sec_info->entry + sec_info->count;
573
      last_fde = buf;
574
 
575
      /* Read the length of the entry.  */
576
      REQUIRE (skip_bytes (&buf, ehbuf + sec->size, 4));
577
      hdr_length = bfd_get_32 (abfd, buf - 4);
578
 
579
      /* The CIE/FDE must be fully contained in this input section.  */
580
      REQUIRE ((bfd_size_type) (buf - ehbuf) + hdr_length <= sec->size);
581
      end = buf + hdr_length;
582
 
583
      this_inf->offset = last_fde - ehbuf;
584
      this_inf->size = 4 + hdr_length;
585
      this_inf->reloc_index = cookie->rel - cookie->rels;
586
 
587
      if (hdr_length == 0)
588
        {
589
          /* A zero-length CIE should only be found at the end of
590
             the section.  */
591
          REQUIRE ((bfd_size_type) (buf - ehbuf) == sec->size);
592
          ENSURE_NO_RELOCS (buf);
593
          sec_info->count++;
594
          break;
595
        }
596
 
597
      REQUIRE (skip_bytes (&buf, end, 4));
598
      hdr_id = bfd_get_32 (abfd, buf - 4);
599
 
600
      if (hdr_id == 0)
601
        {
602
          unsigned int initial_insn_length;
603
 
604
          /* CIE  */
605
          this_inf->cie = 1;
606
 
607
          /* Point CIE to one of the section-local cie structures.  */
608
          cie = local_cies + cie_count++;
609
 
610
          cie->cie_inf = this_inf;
611
          cie->length = hdr_length;
612
          cie->output_sec = sec->output_section;
613
          start = buf;
614
          REQUIRE (read_byte (&buf, end, &cie->version));
615
 
616
          /* Cannot handle unknown versions.  */
617
          REQUIRE (cie->version == 1 || cie->version == 3);
618
          REQUIRE (strlen ((char *) buf) < sizeof (cie->augmentation));
619
 
620
          strcpy (cie->augmentation, (char *) buf);
621
          buf = (bfd_byte *) strchr ((char *) buf, '\0') + 1;
622
          ENSURE_NO_RELOCS (buf);
623
          if (buf[0] == 'e' && buf[1] == 'h')
624
            {
625
              /* GCC < 3.0 .eh_frame CIE */
626
              /* We cannot merge "eh" CIEs because __EXCEPTION_TABLE__
627
                 is private to each CIE, so we don't need it for anything.
628
                 Just skip it.  */
629
              REQUIRE (skip_bytes (&buf, end, ptr_size));
630
              SKIP_RELOCS (buf);
631
            }
632
          REQUIRE (read_uleb128 (&buf, end, &cie->code_align));
633
          REQUIRE (read_sleb128 (&buf, end, &cie->data_align));
634
          if (cie->version == 1)
635
            {
636
              REQUIRE (buf < end);
637
              cie->ra_column = *buf++;
638
            }
639
          else
640
            REQUIRE (read_uleb128 (&buf, end, &cie->ra_column));
641
          ENSURE_NO_RELOCS (buf);
642
          cie->lsda_encoding = DW_EH_PE_omit;
643
          cie->fde_encoding = DW_EH_PE_omit;
644
          cie->per_encoding = DW_EH_PE_omit;
645
          aug = cie->augmentation;
646
          if (aug[0] != 'e' || aug[1] != 'h')
647
            {
648
              if (*aug == 'z')
649
                {
650
                  aug++;
651
                  REQUIRE (read_uleb128 (&buf, end, &cie->augmentation_size));
652
                  ENSURE_NO_RELOCS (buf);
653
                }
654
 
655
              while (*aug != '\0')
656
                switch (*aug++)
657
                  {
658
                  case 'L':
659
                    REQUIRE (read_byte (&buf, end, &cie->lsda_encoding));
660
                    ENSURE_NO_RELOCS (buf);
661
                    REQUIRE (get_DW_EH_PE_width (cie->lsda_encoding, ptr_size));
662
                    break;
663
                  case 'R':
664
                    REQUIRE (read_byte (&buf, end, &cie->fde_encoding));
665
                    ENSURE_NO_RELOCS (buf);
666
                    REQUIRE (get_DW_EH_PE_width (cie->fde_encoding, ptr_size));
667
                    break;
668
                  case 'S':
669
                    break;
670
                  case 'P':
671
                    {
672
                      int per_width;
673
 
674
                      REQUIRE (read_byte (&buf, end, &cie->per_encoding));
675
                      per_width = get_DW_EH_PE_width (cie->per_encoding,
676
                                                      ptr_size);
677
                      REQUIRE (per_width);
678
                      if ((cie->per_encoding & 0xf0) == DW_EH_PE_aligned)
679
                        {
680
                          length = -(buf - ehbuf) & (per_width - 1);
681
                          REQUIRE (skip_bytes (&buf, end, length));
682
                        }
683
                      ENSURE_NO_RELOCS (buf);
684
                      /* Ensure we have a reloc here.  */
685
                      REQUIRE (GET_RELOC (buf));
686
                      cie->personality.reloc_index
687
                        = cookie->rel - cookie->rels;
688
                      /* Cope with MIPS-style composite relocations.  */
689
                      do
690
                        cookie->rel++;
691
                      while (GET_RELOC (buf) != NULL);
692
                      REQUIRE (skip_bytes (&buf, end, per_width));
693
                    }
694
                    break;
695
                  default:
696
                    /* Unrecognized augmentation. Better bail out.  */
697
                    goto free_no_table;
698
                  }
699
            }
700
 
701
          /* For shared libraries, try to get rid of as many RELATIVE relocs
702
             as possible.  */
703
          if (info->shared
704
              && (get_elf_backend_data (abfd)
705
                  ->elf_backend_can_make_relative_eh_frame
706
                  (abfd, info, sec)))
707
            {
708
              if ((cie->fde_encoding & 0xf0) == DW_EH_PE_absptr)
709
                this_inf->make_relative = 1;
710
              /* If the CIE doesn't already have an 'R' entry, it's fairly
711
                 easy to add one, provided that there's no aligned data
712
                 after the augmentation string.  */
713
              else if (cie->fde_encoding == DW_EH_PE_omit
714
                       && (cie->per_encoding & 0xf0) != DW_EH_PE_aligned)
715
                {
716
                  if (*cie->augmentation == 0)
717
                    this_inf->add_augmentation_size = 1;
718
                  this_inf->u.cie.add_fde_encoding = 1;
719
                  this_inf->make_relative = 1;
720
                }
721
            }
722
 
723
          if (info->shared
724
              && (get_elf_backend_data (abfd)
725
                  ->elf_backend_can_make_lsda_relative_eh_frame
726
                  (abfd, info, sec))
727
              && (cie->lsda_encoding & 0xf0) == DW_EH_PE_absptr)
728
            cie->can_make_lsda_relative = 1;
729
 
730
          /* If FDE encoding was not specified, it defaults to
731
             DW_EH_absptr.  */
732
          if (cie->fde_encoding == DW_EH_PE_omit)
733
            cie->fde_encoding = DW_EH_PE_absptr;
734
 
735
          initial_insn_length = end - buf;
736
          if (initial_insn_length <= sizeof (cie->initial_instructions))
737
            {
738
              cie->initial_insn_length = initial_insn_length;
739
              memcpy (cie->initial_instructions, buf, initial_insn_length);
740
            }
741
          insns = buf;
742
          buf += initial_insn_length;
743
          ENSURE_NO_RELOCS (buf);
744
 
745
          if (hdr_info->merge_cies)
746
            this_inf->u.cie.u.full_cie = cie;
747
          this_inf->u.cie.per_encoding_relative
748
            = (cie->per_encoding & 0x70) == DW_EH_PE_pcrel;
749
        }
750
      else
751
        {
752
          asection *rsec;
753
 
754
          /* Find the corresponding CIE.  */
755
          unsigned int cie_offset = this_inf->offset + 4 - hdr_id;
756
          for (cie = local_cies; cie < local_cies + cie_count; cie++)
757
            if (cie_offset == cie->cie_inf->offset)
758
              break;
759
 
760
          /* Ensure this FDE references one of the CIEs in this input
761
             section.  */
762
          REQUIRE (cie != local_cies + cie_count);
763
          this_inf->u.fde.cie_inf = cie->cie_inf;
764
          this_inf->make_relative = cie->cie_inf->make_relative;
765
          this_inf->add_augmentation_size
766
            = cie->cie_inf->add_augmentation_size;
767
 
768
          ENSURE_NO_RELOCS (buf);
769
          REQUIRE (GET_RELOC (buf));
770
 
771
          /* Chain together the FDEs for each section.  */
772
          rsec = _bfd_elf_gc_mark_rsec (info, sec, gc_mark_hook, cookie);
773 225 jeremybenn
          /* RSEC will be NULL if FDE was cleared out as it was belonging to
774
             a discarded SHT_GROUP.  */
775
          if (rsec)
776
            {
777
              REQUIRE (rsec->owner == abfd);
778
              this_inf->u.fde.next_for_section = elf_fde_list (rsec);
779
              elf_fde_list (rsec) = this_inf;
780
            }
781 24 jeremybenn
 
782
          /* Skip the initial location and address range.  */
783
          start = buf;
784
          length = get_DW_EH_PE_width (cie->fde_encoding, ptr_size);
785
          REQUIRE (skip_bytes (&buf, end, 2 * length));
786
 
787
          /* Skip the augmentation size, if present.  */
788
          if (cie->augmentation[0] == 'z')
789
            REQUIRE (read_uleb128 (&buf, end, &length));
790
          else
791
            length = 0;
792
 
793
          /* Of the supported augmentation characters above, only 'L'
794
             adds augmentation data to the FDE.  This code would need to
795
             be adjusted if any future augmentations do the same thing.  */
796
          if (cie->lsda_encoding != DW_EH_PE_omit)
797
            {
798
              SKIP_RELOCS (buf);
799
              if (cie->can_make_lsda_relative && GET_RELOC (buf))
800
                cie->cie_inf->u.cie.make_lsda_relative = 1;
801
              this_inf->lsda_offset = buf - start;
802
              /* If there's no 'z' augmentation, we don't know where the
803
                 CFA insns begin.  Assume no padding.  */
804
              if (cie->augmentation[0] != 'z')
805
                length = end - buf;
806
            }
807
 
808
          /* Skip over the augmentation data.  */
809
          REQUIRE (skip_bytes (&buf, end, length));
810
          insns = buf;
811
 
812
          buf = last_fde + 4 + hdr_length;
813 225 jeremybenn
 
814
          /* For NULL RSEC (cleared FDE belonging to a discarded section)
815
             the relocations are commonly cleared.  We do not sanity check if
816
             all these relocations are cleared as (1) relocations to
817
             .gcc_except_table will remain uncleared (they will get dropped
818
             with the drop of this unused FDE) and (2) BFD already safely drops
819
             relocations of any type to .eh_frame by
820
             elf_section_ignore_discarded_relocs.
821
             TODO: The .gcc_except_table entries should be also filtered as
822
             .eh_frame entries; or GCC could rather use COMDAT for them.  */
823 24 jeremybenn
          SKIP_RELOCS (buf);
824
        }
825
 
826
      /* Try to interpret the CFA instructions and find the first
827
         padding nop.  Shrink this_inf's size so that it doesn't
828
         include the padding.  */
829
      length = get_DW_EH_PE_width (cie->fde_encoding, ptr_size);
830
      set_loc_count = 0;
831
      insns_end = skip_non_nops (insns, end, length, &set_loc_count);
832
      /* If we don't understand the CFA instructions, we can't know
833
         what needs to be adjusted there.  */
834
      if (insns_end == NULL
835
          /* For the time being we don't support DW_CFA_set_loc in
836
             CIE instructions.  */
837
          || (set_loc_count && this_inf->cie))
838
        goto free_no_table;
839
      this_inf->size -= end - insns_end;
840
      if (insns_end != end && this_inf->cie)
841
        {
842
          cie->initial_insn_length -= end - insns_end;
843
          cie->length -= end - insns_end;
844
        }
845
      if (set_loc_count
846
          && ((cie->fde_encoding & 0xf0) == DW_EH_PE_pcrel
847
              || this_inf->make_relative))
848
        {
849
          unsigned int cnt;
850
          bfd_byte *p;
851
 
852 225 jeremybenn
          this_inf->set_loc = (unsigned int *)
853
              bfd_malloc ((set_loc_count + 1) * sizeof (unsigned int));
854 24 jeremybenn
          REQUIRE (this_inf->set_loc);
855
          this_inf->set_loc[0] = set_loc_count;
856
          p = insns;
857
          cnt = 0;
858
          while (p < end)
859
            {
860
              if (*p == DW_CFA_set_loc)
861
                this_inf->set_loc[++cnt] = p + 1 - start;
862
              REQUIRE (skip_cfa_op (&p, end, length));
863
            }
864
        }
865
 
866
      this_inf->removed = 1;
867
      this_inf->fde_encoding = cie->fde_encoding;
868
      this_inf->lsda_encoding = cie->lsda_encoding;
869
      sec_info->count++;
870
    }
871
  BFD_ASSERT (sec_info->count == num_entries);
872
  BFD_ASSERT (cie_count == num_cies);
873
 
874
  elf_section_data (sec)->sec_info = sec_info;
875
  sec->sec_info_type = ELF_INFO_TYPE_EH_FRAME;
876
  if (hdr_info->merge_cies)
877
    {
878
      sec_info->cies = local_cies;
879
      local_cies = NULL;
880
    }
881
  goto success;
882
 
883
 free_no_table:
884
  (*info->callbacks->einfo)
885
    (_("%P: error in %B(%A); no .eh_frame_hdr table will be created.\n"),
886
     abfd, sec);
887
  hdr_info->table = FALSE;
888
  if (sec_info)
889
    free (sec_info);
890
 success:
891
  if (ehbuf)
892
    free (ehbuf);
893
  if (local_cies)
894
    free (local_cies);
895
#undef REQUIRE
896
}
897
 
898
/* Finish a pass over all .eh_frame sections.  */
899
 
900
void
901
_bfd_elf_end_eh_frame_parsing (struct bfd_link_info *info)
902
{
903
  struct eh_frame_hdr_info *hdr_info;
904
 
905
  hdr_info = &elf_hash_table (info)->eh_info;
906
  hdr_info->parsed_eh_frames = TRUE;
907
}
908
 
909
/* Mark all relocations against CIE or FDE ENT, which occurs in
910
   .eh_frame section SEC.  COOKIE describes the relocations in SEC;
911
   its "rel" field can be changed freely.  */
912
 
913
static bfd_boolean
914
mark_entry (struct bfd_link_info *info, asection *sec,
915
            struct eh_cie_fde *ent, elf_gc_mark_hook_fn gc_mark_hook,
916
            struct elf_reloc_cookie *cookie)
917
{
918 225 jeremybenn
  /* FIXME: octets_per_byte.  */
919 24 jeremybenn
  for (cookie->rel = cookie->rels + ent->reloc_index;
920
       cookie->rel < cookie->relend
921
         && cookie->rel->r_offset < ent->offset + ent->size;
922
       cookie->rel++)
923
    if (!_bfd_elf_gc_mark_reloc (info, sec, gc_mark_hook, cookie))
924
      return FALSE;
925
 
926
  return TRUE;
927
}
928
 
929
/* Mark all the relocations against FDEs that relate to code in input
930
   section SEC.  The FDEs belong to .eh_frame section EH_FRAME, whose
931
   relocations are described by COOKIE.  */
932
 
933
bfd_boolean
934
_bfd_elf_gc_mark_fdes (struct bfd_link_info *info, asection *sec,
935
                       asection *eh_frame, elf_gc_mark_hook_fn gc_mark_hook,
936
                       struct elf_reloc_cookie *cookie)
937
{
938
  struct eh_cie_fde *fde, *cie;
939
 
940
  for (fde = elf_fde_list (sec); fde; fde = fde->u.fde.next_for_section)
941
    {
942
      if (!mark_entry (info, eh_frame, fde, gc_mark_hook, cookie))
943
        return FALSE;
944
 
945
      /* At this stage, all cie_inf fields point to local CIEs, so we
946
         can use the same cookie to refer to them.  */
947
      cie = fde->u.fde.cie_inf;
948
      if (!cie->u.cie.gc_mark)
949
        {
950
          cie->u.cie.gc_mark = 1;
951
          if (!mark_entry (info, eh_frame, cie, gc_mark_hook, cookie))
952
            return FALSE;
953
        }
954
    }
955
  return TRUE;
956
}
957
 
958
/* Input section SEC of ABFD is an .eh_frame section that contains the
959
   CIE described by CIE_INF.  Return a version of CIE_INF that is going
960
   to be kept in the output, adding CIE_INF to the output if necessary.
961
 
962
   HDR_INFO is the .eh_frame_hdr information and COOKIE describes the
963
   relocations in REL.  */
964
 
965
static struct eh_cie_fde *
966
find_merged_cie (bfd *abfd, asection *sec,
967
                 struct eh_frame_hdr_info *hdr_info,
968
                 struct elf_reloc_cookie *cookie,
969
                 struct eh_cie_fde *cie_inf)
970
{
971
  unsigned long r_symndx;
972
  struct cie *cie, *new_cie;
973
  Elf_Internal_Rela *rel;
974
  void **loc;
975
 
976
  /* Use CIE_INF if we have already decided to keep it.  */
977
  if (!cie_inf->removed)
978
    return cie_inf;
979
 
980
  /* If we have merged CIE_INF with another CIE, use that CIE instead.  */
981
  if (cie_inf->u.cie.merged)
982
    return cie_inf->u.cie.u.merged_with;
983
 
984
  cie = cie_inf->u.cie.u.full_cie;
985
 
986
  /* Assume we will need to keep CIE_INF.  */
987
  cie_inf->removed = 0;
988
  cie_inf->u.cie.u.sec = sec;
989
 
990
  /* If we are not merging CIEs, use CIE_INF.  */
991
  if (cie == NULL)
992
    return cie_inf;
993
 
994
  if (cie->per_encoding != DW_EH_PE_omit)
995
    {
996
      /* Work out the address of personality routine, either as an absolute
997
         value or as a symbol.  */
998
      rel = cookie->rels + cie->personality.reloc_index;
999
      memset (&cie->personality, 0, sizeof (cie->personality));
1000
#ifdef BFD64
1001
      if (elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64)
1002
        r_symndx = ELF64_R_SYM (rel->r_info);
1003
      else
1004
#endif
1005
        r_symndx = ELF32_R_SYM (rel->r_info);
1006
      if (r_symndx >= cookie->locsymcount
1007
          || ELF_ST_BIND (cookie->locsyms[r_symndx].st_info) != STB_LOCAL)
1008
        {
1009
          struct elf_link_hash_entry *h;
1010
 
1011
          r_symndx -= cookie->extsymoff;
1012
          h = cookie->sym_hashes[r_symndx];
1013
 
1014
          while (h->root.type == bfd_link_hash_indirect
1015
                 || h->root.type == bfd_link_hash_warning)
1016
            h = (struct elf_link_hash_entry *) h->root.u.i.link;
1017
 
1018
          cie->personality.h = h;
1019
        }
1020
      else
1021
        {
1022
          Elf_Internal_Sym *sym;
1023
          asection *sym_sec;
1024
 
1025
          sym = &cookie->locsyms[r_symndx];
1026
          sym_sec = bfd_section_from_elf_index (abfd, sym->st_shndx);
1027
          if (sym_sec == NULL)
1028
            return cie_inf;
1029
 
1030
          if (sym_sec->kept_section != NULL)
1031
            sym_sec = sym_sec->kept_section;
1032
          if (sym_sec->output_section == NULL)
1033
            return cie_inf;
1034
 
1035
          cie->local_personality = 1;
1036
          cie->personality.val = (sym->st_value
1037
                                  + sym_sec->output_offset
1038
                                  + sym_sec->output_section->vma);
1039
        }
1040
    }
1041
 
1042
  /* See if we can merge this CIE with an earlier one.  */
1043
  cie->output_sec = sec->output_section;
1044
  cie_compute_hash (cie);
1045
  if (hdr_info->cies == NULL)
1046
    {
1047
      hdr_info->cies = htab_try_create (1, cie_hash, cie_eq, free);
1048
      if (hdr_info->cies == NULL)
1049
        return cie_inf;
1050
    }
1051
  loc = htab_find_slot_with_hash (hdr_info->cies, cie, cie->hash, INSERT);
1052
  if (loc == NULL)
1053
    return cie_inf;
1054
 
1055
  new_cie = (struct cie *) *loc;
1056
  if (new_cie == NULL)
1057
    {
1058
      /* Keep CIE_INF and record it in the hash table.  */
1059 225 jeremybenn
      new_cie = (struct cie *) malloc (sizeof (struct cie));
1060 24 jeremybenn
      if (new_cie == NULL)
1061
        return cie_inf;
1062
 
1063
      memcpy (new_cie, cie, sizeof (struct cie));
1064
      *loc = new_cie;
1065
    }
1066
  else
1067
    {
1068
      /* Merge CIE_INF with NEW_CIE->CIE_INF.  */
1069
      cie_inf->removed = 1;
1070
      cie_inf->u.cie.merged = 1;
1071
      cie_inf->u.cie.u.merged_with = new_cie->cie_inf;
1072
      if (cie_inf->u.cie.make_lsda_relative)
1073
        new_cie->cie_inf->u.cie.make_lsda_relative = 1;
1074
    }
1075
  return new_cie->cie_inf;
1076
}
1077
 
1078
/* This function is called for each input file before the .eh_frame
1079
   section is relocated.  It discards duplicate CIEs and FDEs for discarded
1080
   functions.  The function returns TRUE iff any entries have been
1081
   deleted.  */
1082
 
1083
bfd_boolean
1084
_bfd_elf_discard_section_eh_frame
1085
   (bfd *abfd, struct bfd_link_info *info, asection *sec,
1086
    bfd_boolean (*reloc_symbol_deleted_p) (bfd_vma, void *),
1087
    struct elf_reloc_cookie *cookie)
1088
{
1089
  struct eh_cie_fde *ent;
1090
  struct eh_frame_sec_info *sec_info;
1091
  struct eh_frame_hdr_info *hdr_info;
1092
  unsigned int ptr_size, offset;
1093
 
1094
  sec_info = (struct eh_frame_sec_info *) elf_section_data (sec)->sec_info;
1095
  if (sec_info == NULL)
1096
    return FALSE;
1097
 
1098
  hdr_info = &elf_hash_table (info)->eh_info;
1099
  for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent)
1100 225 jeremybenn
    if (ent->size == 4)
1101
      /* There should only be one zero terminator, on the last input
1102
         file supplying .eh_frame (crtend.o).  Remove any others.  */
1103
      ent->removed = sec->map_head.s != NULL;
1104
    else if (!ent->cie)
1105 24 jeremybenn
      {
1106
        cookie->rel = cookie->rels + ent->reloc_index;
1107 225 jeremybenn
        /* FIXME: octets_per_byte.  */
1108 24 jeremybenn
        BFD_ASSERT (cookie->rel < cookie->relend
1109
                    && cookie->rel->r_offset == ent->offset + 8);
1110
        if (!(*reloc_symbol_deleted_p) (ent->offset + 8, cookie))
1111
          {
1112
            if (info->shared
1113
                && (((ent->fde_encoding & 0xf0) == DW_EH_PE_absptr
1114
                     && ent->make_relative == 0)
1115
                    || (ent->fde_encoding & 0xf0) == DW_EH_PE_aligned))
1116
              {
1117
                /* If a shared library uses absolute pointers
1118
                   which we cannot turn into PC relative,
1119
                   don't create the binary search table,
1120
                   since it is affected by runtime relocations.  */
1121
                hdr_info->table = FALSE;
1122
                (*info->callbacks->einfo)
1123
                  (_("%P: fde encoding in %B(%A) prevents .eh_frame_hdr"
1124
                     " table being created.\n"), abfd, sec);
1125
              }
1126
            ent->removed = 0;
1127
            hdr_info->fde_count++;
1128
            ent->u.fde.cie_inf = find_merged_cie (abfd, sec, hdr_info, cookie,
1129
                                                  ent->u.fde.cie_inf);
1130
          }
1131
      }
1132
 
1133
  if (sec_info->cies)
1134
    {
1135
      free (sec_info->cies);
1136
      sec_info->cies = NULL;
1137
    }
1138
 
1139
  ptr_size = (get_elf_backend_data (sec->owner)
1140
              ->elf_backend_eh_frame_address_size (sec->owner, sec));
1141
  offset = 0;
1142
  for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent)
1143
    if (!ent->removed)
1144
      {
1145
        ent->new_offset = offset;
1146
        offset += size_of_output_cie_fde (ent, ptr_size);
1147
      }
1148
 
1149
  sec->rawsize = sec->size;
1150
  sec->size = offset;
1151
  return offset != sec->rawsize;
1152
}
1153
 
1154
/* This function is called for .eh_frame_hdr section after
1155
   _bfd_elf_discard_section_eh_frame has been called on all .eh_frame
1156
   input sections.  It finalizes the size of .eh_frame_hdr section.  */
1157
 
1158
bfd_boolean
1159
_bfd_elf_discard_section_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info)
1160
{
1161
  struct elf_link_hash_table *htab;
1162
  struct eh_frame_hdr_info *hdr_info;
1163
  asection *sec;
1164
 
1165
  htab = elf_hash_table (info);
1166
  hdr_info = &htab->eh_info;
1167
 
1168
  if (hdr_info->cies != NULL)
1169
    {
1170
      htab_delete (hdr_info->cies);
1171
      hdr_info->cies = NULL;
1172
    }
1173
 
1174
  sec = hdr_info->hdr_sec;
1175
  if (sec == NULL)
1176
    return FALSE;
1177
 
1178
  sec->size = EH_FRAME_HDR_SIZE;
1179
  if (hdr_info->table)
1180
    sec->size += 4 + hdr_info->fde_count * 8;
1181
 
1182
  elf_tdata (abfd)->eh_frame_hdr = sec;
1183
  return TRUE;
1184
}
1185
 
1186
/* This function is called from size_dynamic_sections.
1187
   It needs to decide whether .eh_frame_hdr should be output or not,
1188
   because when the dynamic symbol table has been sized it is too late
1189
   to strip sections.  */
1190
 
1191
bfd_boolean
1192
_bfd_elf_maybe_strip_eh_frame_hdr (struct bfd_link_info *info)
1193
{
1194
  asection *o;
1195
  bfd *abfd;
1196
  struct elf_link_hash_table *htab;
1197
  struct eh_frame_hdr_info *hdr_info;
1198
 
1199
  htab = elf_hash_table (info);
1200
  hdr_info = &htab->eh_info;
1201
  if (hdr_info->hdr_sec == NULL)
1202
    return TRUE;
1203
 
1204
  if (bfd_is_abs_section (hdr_info->hdr_sec->output_section))
1205
    {
1206
      hdr_info->hdr_sec = NULL;
1207
      return TRUE;
1208
    }
1209
 
1210
  abfd = NULL;
1211
  if (info->eh_frame_hdr)
1212
    for (abfd = info->input_bfds; abfd != NULL; abfd = abfd->link_next)
1213
      {
1214
        /* Count only sections which have at least a single CIE or FDE.
1215
           There cannot be any CIE or FDE <= 8 bytes.  */
1216
        o = bfd_get_section_by_name (abfd, ".eh_frame");
1217
        if (o && o->size > 8 && !bfd_is_abs_section (o->output_section))
1218
          break;
1219
      }
1220
 
1221
  if (abfd == NULL)
1222
    {
1223
      hdr_info->hdr_sec->flags |= SEC_EXCLUDE;
1224
      hdr_info->hdr_sec = NULL;
1225
      return TRUE;
1226
    }
1227
 
1228
  hdr_info->table = TRUE;
1229
  return TRUE;
1230
}
1231
 
1232
/* Adjust an address in the .eh_frame section.  Given OFFSET within
1233
   SEC, this returns the new offset in the adjusted .eh_frame section,
1234
   or -1 if the address refers to a CIE/FDE which has been removed
1235
   or to offset with dynamic relocation which is no longer needed.  */
1236
 
1237
bfd_vma
1238
_bfd_elf_eh_frame_section_offset (bfd *output_bfd ATTRIBUTE_UNUSED,
1239
                                  struct bfd_link_info *info,
1240
                                  asection *sec,
1241
                                  bfd_vma offset)
1242
{
1243
  struct eh_frame_sec_info *sec_info;
1244
  struct elf_link_hash_table *htab;
1245
  struct eh_frame_hdr_info *hdr_info;
1246
  unsigned int lo, hi, mid;
1247
 
1248
  if (sec->sec_info_type != ELF_INFO_TYPE_EH_FRAME)
1249
    return offset;
1250 225 jeremybenn
  sec_info = (struct eh_frame_sec_info *) elf_section_data (sec)->sec_info;
1251 24 jeremybenn
 
1252
  if (offset >= sec->rawsize)
1253
    return offset - sec->rawsize + sec->size;
1254
 
1255
  htab = elf_hash_table (info);
1256
  hdr_info = &htab->eh_info;
1257
 
1258
  lo = 0;
1259
  hi = sec_info->count;
1260
  mid = 0;
1261
  while (lo < hi)
1262
    {
1263
      mid = (lo + hi) / 2;
1264
      if (offset < sec_info->entry[mid].offset)
1265
        hi = mid;
1266
      else if (offset
1267
               >= sec_info->entry[mid].offset + sec_info->entry[mid].size)
1268
        lo = mid + 1;
1269
      else
1270
        break;
1271
    }
1272
 
1273
  BFD_ASSERT (lo < hi);
1274
 
1275
  /* FDE or CIE was removed.  */
1276
  if (sec_info->entry[mid].removed)
1277
    return (bfd_vma) -1;
1278
 
1279
  /* If converting to DW_EH_PE_pcrel, there will be no need for run-time
1280
     relocation against FDE's initial_location field.  */
1281
  if (!sec_info->entry[mid].cie
1282
      && sec_info->entry[mid].make_relative
1283
      && offset == sec_info->entry[mid].offset + 8)
1284
    return (bfd_vma) -2;
1285
 
1286
  /* If converting LSDA pointers to DW_EH_PE_pcrel, there will be no need
1287
     for run-time relocation against LSDA field.  */
1288
  if (!sec_info->entry[mid].cie
1289
      && sec_info->entry[mid].u.fde.cie_inf->u.cie.make_lsda_relative
1290
      && offset == (sec_info->entry[mid].offset + 8
1291
                    + sec_info->entry[mid].lsda_offset))
1292
    return (bfd_vma) -2;
1293
 
1294
  /* If converting to DW_EH_PE_pcrel, there will be no need for run-time
1295
     relocation against DW_CFA_set_loc's arguments.  */
1296
  if (sec_info->entry[mid].set_loc
1297
      && sec_info->entry[mid].make_relative
1298
      && (offset >= sec_info->entry[mid].offset + 8
1299
                    + sec_info->entry[mid].set_loc[1]))
1300
    {
1301
      unsigned int cnt;
1302
 
1303
      for (cnt = 1; cnt <= sec_info->entry[mid].set_loc[0]; cnt++)
1304
        if (offset == sec_info->entry[mid].offset + 8
1305
                      + sec_info->entry[mid].set_loc[cnt])
1306
          return (bfd_vma) -2;
1307
    }
1308
 
1309
  /* Any new augmentation bytes go before the first relocation.  */
1310
  return (offset + sec_info->entry[mid].new_offset
1311
          - sec_info->entry[mid].offset
1312
          + extra_augmentation_string_bytes (sec_info->entry + mid)
1313
          + extra_augmentation_data_bytes (sec_info->entry + mid));
1314
}
1315
 
1316
/* Write out .eh_frame section.  This is called with the relocated
1317
   contents.  */
1318
 
1319
bfd_boolean
1320
_bfd_elf_write_section_eh_frame (bfd *abfd,
1321
                                 struct bfd_link_info *info,
1322
                                 asection *sec,
1323
                                 bfd_byte *contents)
1324
{
1325
  struct eh_frame_sec_info *sec_info;
1326
  struct elf_link_hash_table *htab;
1327
  struct eh_frame_hdr_info *hdr_info;
1328
  unsigned int ptr_size;
1329
  struct eh_cie_fde *ent;
1330
 
1331
  if (sec->sec_info_type != ELF_INFO_TYPE_EH_FRAME)
1332 225 jeremybenn
    /* FIXME: octets_per_byte.  */
1333 24 jeremybenn
    return bfd_set_section_contents (abfd, sec->output_section, contents,
1334
                                     sec->output_offset, sec->size);
1335
 
1336
  ptr_size = (get_elf_backend_data (abfd)
1337
              ->elf_backend_eh_frame_address_size (abfd, sec));
1338
  BFD_ASSERT (ptr_size != 0);
1339
 
1340 225 jeremybenn
  sec_info = (struct eh_frame_sec_info *) elf_section_data (sec)->sec_info;
1341 24 jeremybenn
  htab = elf_hash_table (info);
1342
  hdr_info = &htab->eh_info;
1343
 
1344
  if (hdr_info->table && hdr_info->array == NULL)
1345 225 jeremybenn
    hdr_info->array = (struct eh_frame_array_ent *)
1346
        bfd_malloc (hdr_info->fde_count * sizeof(*hdr_info->array));
1347 24 jeremybenn
  if (hdr_info->array == NULL)
1348
    hdr_info = NULL;
1349
 
1350
  /* The new offsets can be bigger or smaller than the original offsets.
1351
     We therefore need to make two passes over the section: one backward
1352
     pass to move entries up and one forward pass to move entries down.
1353
     The two passes won't interfere with each other because entries are
1354
     not reordered  */
1355
  for (ent = sec_info->entry + sec_info->count; ent-- != sec_info->entry;)
1356
    if (!ent->removed && ent->new_offset > ent->offset)
1357
      memmove (contents + ent->new_offset, contents + ent->offset, ent->size);
1358
 
1359
  for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent)
1360
    if (!ent->removed && ent->new_offset < ent->offset)
1361
      memmove (contents + ent->new_offset, contents + ent->offset, ent->size);
1362
 
1363
  for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent)
1364
    {
1365
      unsigned char *buf, *end;
1366
      unsigned int new_size;
1367
 
1368
      if (ent->removed)
1369
        continue;
1370
 
1371
      if (ent->size == 4)
1372
        {
1373
          /* Any terminating FDE must be at the end of the section.  */
1374
          BFD_ASSERT (ent == sec_info->entry + sec_info->count - 1);
1375
          continue;
1376
        }
1377
 
1378
      buf = contents + ent->new_offset;
1379
      end = buf + ent->size;
1380
      new_size = size_of_output_cie_fde (ent, ptr_size);
1381
 
1382
      /* Update the size.  It may be shrinked.  */
1383
      bfd_put_32 (abfd, new_size - 4, buf);
1384
 
1385
      /* Filling the extra bytes with DW_CFA_nops.  */
1386
      if (new_size != ent->size)
1387
        memset (end, 0, new_size - ent->size);
1388
 
1389
      if (ent->cie)
1390
        {
1391
          /* CIE */
1392
          if (ent->make_relative
1393
              || ent->u.cie.make_lsda_relative
1394
              || ent->u.cie.per_encoding_relative)
1395
            {
1396
              char *aug;
1397
              unsigned int action, extra_string, extra_data;
1398
              unsigned int per_width, per_encoding;
1399
 
1400
              /* Need to find 'R' or 'L' augmentation's argument and modify
1401
                 DW_EH_PE_* value.  */
1402
              action = ((ent->make_relative ? 1 : 0)
1403
                        | (ent->u.cie.make_lsda_relative ? 2 : 0)
1404
                        | (ent->u.cie.per_encoding_relative ? 4 : 0));
1405
              extra_string = extra_augmentation_string_bytes (ent);
1406
              extra_data = extra_augmentation_data_bytes (ent);
1407
 
1408
              /* Skip length, id and version.  */
1409
              buf += 9;
1410
              aug = (char *) buf;
1411
              buf += strlen (aug) + 1;
1412
              skip_leb128 (&buf, end);
1413
              skip_leb128 (&buf, end);
1414
              skip_leb128 (&buf, end);
1415
              if (*aug == 'z')
1416
                {
1417
                  /* The uleb128 will always be a single byte for the kind
1418
                     of augmentation strings that we're prepared to handle.  */
1419
                  *buf++ += extra_data;
1420
                  aug++;
1421
                }
1422
 
1423
              /* Make room for the new augmentation string and data bytes.  */
1424
              memmove (buf + extra_string + extra_data, buf, end - buf);
1425
              memmove (aug + extra_string, aug, buf - (bfd_byte *) aug);
1426
              buf += extra_string;
1427
              end += extra_string + extra_data;
1428
 
1429
              if (ent->add_augmentation_size)
1430
                {
1431
                  *aug++ = 'z';
1432
                  *buf++ = extra_data - 1;
1433
                }
1434
              if (ent->u.cie.add_fde_encoding)
1435
                {
1436
                  BFD_ASSERT (action & 1);
1437
                  *aug++ = 'R';
1438
                  *buf++ = DW_EH_PE_pcrel;
1439
                  action &= ~1;
1440
                }
1441
 
1442
              while (action)
1443
                switch (*aug++)
1444
                  {
1445
                  case 'L':
1446
                    if (action & 2)
1447
                      {
1448
                        BFD_ASSERT (*buf == ent->lsda_encoding);
1449
                        *buf |= DW_EH_PE_pcrel;
1450
                        action &= ~2;
1451
                      }
1452
                    buf++;
1453
                    break;
1454
                  case 'P':
1455
                    per_encoding = *buf++;
1456
                    per_width = get_DW_EH_PE_width (per_encoding, ptr_size);
1457
                    BFD_ASSERT (per_width != 0);
1458
                    BFD_ASSERT (((per_encoding & 0x70) == DW_EH_PE_pcrel)
1459
                                == ent->u.cie.per_encoding_relative);
1460
                    if ((per_encoding & 0xf0) == DW_EH_PE_aligned)
1461
                      buf = (contents
1462
                             + ((buf - contents + per_width - 1)
1463
                                & ~((bfd_size_type) per_width - 1)));
1464
                    if (action & 4)
1465
                      {
1466
                        bfd_vma val;
1467
 
1468
                        val = read_value (abfd, buf, per_width,
1469
                                          get_DW_EH_PE_signed (per_encoding));
1470 225 jeremybenn
                        val += (bfd_vma) ent->offset - ent->new_offset;
1471 24 jeremybenn
                        val -= extra_string + extra_data;
1472
                        write_value (abfd, buf, val, per_width);
1473
                        action &= ~4;
1474
                      }
1475
                    buf += per_width;
1476
                    break;
1477
                  case 'R':
1478
                    if (action & 1)
1479
                      {
1480
                        BFD_ASSERT (*buf == ent->fde_encoding);
1481
                        *buf |= DW_EH_PE_pcrel;
1482
                        action &= ~1;
1483
                      }
1484
                    buf++;
1485
                    break;
1486
                  case 'S':
1487
                    break;
1488
                  default:
1489
                    BFD_FAIL ();
1490
                  }
1491
            }
1492
        }
1493
      else
1494
        {
1495
          /* FDE */
1496
          bfd_vma value, address;
1497
          unsigned int width;
1498
          bfd_byte *start;
1499
          struct eh_cie_fde *cie;
1500
 
1501
          /* Skip length.  */
1502
          cie = ent->u.fde.cie_inf;
1503
          buf += 4;
1504
          value = ((ent->new_offset + sec->output_offset + 4)
1505
                   - (cie->new_offset + cie->u.cie.u.sec->output_offset));
1506
          bfd_put_32 (abfd, value, buf);
1507
          buf += 4;
1508
          width = get_DW_EH_PE_width (ent->fde_encoding, ptr_size);
1509
          value = read_value (abfd, buf, width,
1510
                              get_DW_EH_PE_signed (ent->fde_encoding));
1511
          address = value;
1512
          if (value)
1513
            {
1514
              switch (ent->fde_encoding & 0xf0)
1515
                {
1516
                case DW_EH_PE_indirect:
1517
                case DW_EH_PE_textrel:
1518
                  BFD_ASSERT (hdr_info == NULL);
1519
                  break;
1520
                case DW_EH_PE_datarel:
1521
                  {
1522
                    asection *got = bfd_get_section_by_name (abfd, ".got");
1523
 
1524
                    BFD_ASSERT (got != NULL);
1525
                    address += got->vma;
1526
                  }
1527
                  break;
1528
                case DW_EH_PE_pcrel:
1529 225 jeremybenn
                  value += (bfd_vma) ent->offset - ent->new_offset;
1530 24 jeremybenn
                  address += (sec->output_section->vma
1531
                              + sec->output_offset
1532
                              + ent->offset + 8);
1533
                  break;
1534
                }
1535
              if (ent->make_relative)
1536
                value -= (sec->output_section->vma
1537
                          + sec->output_offset
1538
                          + ent->new_offset + 8);
1539
              write_value (abfd, buf, value, width);
1540
            }
1541
 
1542
          start = buf;
1543
 
1544
          if (hdr_info)
1545
            {
1546
              hdr_info->array[hdr_info->array_count].initial_loc = address;
1547
              hdr_info->array[hdr_info->array_count++].fde
1548
                = (sec->output_section->vma
1549
                   + sec->output_offset
1550
                   + ent->new_offset);
1551
            }
1552
 
1553
          if ((ent->lsda_encoding & 0xf0) == DW_EH_PE_pcrel
1554
              || cie->u.cie.make_lsda_relative)
1555
            {
1556
              buf += ent->lsda_offset;
1557
              width = get_DW_EH_PE_width (ent->lsda_encoding, ptr_size);
1558
              value = read_value (abfd, buf, width,
1559
                                  get_DW_EH_PE_signed (ent->lsda_encoding));
1560
              if (value)
1561
                {
1562
                  if ((ent->lsda_encoding & 0xf0) == DW_EH_PE_pcrel)
1563 225 jeremybenn
                    value += (bfd_vma) ent->offset - ent->new_offset;
1564 24 jeremybenn
                  else if (cie->u.cie.make_lsda_relative)
1565
                    value -= (sec->output_section->vma
1566
                              + sec->output_offset
1567
                              + ent->new_offset + 8 + ent->lsda_offset);
1568
                  write_value (abfd, buf, value, width);
1569
                }
1570
            }
1571
          else if (ent->add_augmentation_size)
1572
            {
1573
              /* Skip the PC and length and insert a zero byte for the
1574
                 augmentation size.  */
1575
              buf += width * 2;
1576
              memmove (buf + 1, buf, end - buf);
1577
              *buf = 0;
1578
            }
1579
 
1580
          if (ent->set_loc)
1581
            {
1582
              /* Adjust DW_CFA_set_loc.  */
1583
              unsigned int cnt, width;
1584
              bfd_vma new_offset;
1585
 
1586
              width = get_DW_EH_PE_width (ent->fde_encoding, ptr_size);
1587
              new_offset = ent->new_offset + 8
1588
                           + extra_augmentation_string_bytes (ent)
1589
                           + extra_augmentation_data_bytes (ent);
1590
 
1591
              for (cnt = 1; cnt <= ent->set_loc[0]; cnt++)
1592
                {
1593
                  bfd_vma value;
1594
                  buf = start + ent->set_loc[cnt];
1595
 
1596
                  value = read_value (abfd, buf, width,
1597
                                      get_DW_EH_PE_signed (ent->fde_encoding));
1598
                  if (!value)
1599
                    continue;
1600
 
1601
                  if ((ent->fde_encoding & 0xf0) == DW_EH_PE_pcrel)
1602 225 jeremybenn
                    value += (bfd_vma) ent->offset + 8 - new_offset;
1603 24 jeremybenn
                  if (ent->make_relative)
1604
                    value -= (sec->output_section->vma
1605
                              + sec->output_offset
1606
                              + new_offset + ent->set_loc[cnt]);
1607
                  write_value (abfd, buf, value, width);
1608
                }
1609
            }
1610
        }
1611
    }
1612
 
1613
  /* We don't align the section to its section alignment since the
1614
     runtime library only expects all CIE/FDE records aligned at
1615
     the pointer size. _bfd_elf_discard_section_eh_frame should
1616
     have padded CIE/FDE records to multiple of pointer size with
1617
     size_of_output_cie_fde.  */
1618
  if ((sec->size % ptr_size) != 0)
1619
    abort ();
1620
 
1621 225 jeremybenn
  /* FIXME: octets_per_byte.  */
1622 24 jeremybenn
  return bfd_set_section_contents (abfd, sec->output_section,
1623
                                   contents, (file_ptr) sec->output_offset,
1624
                                   sec->size);
1625
}
1626
 
1627
/* Helper function used to sort .eh_frame_hdr search table by increasing
1628
   VMA of FDE initial location.  */
1629
 
1630
static int
1631
vma_compare (const void *a, const void *b)
1632
{
1633 225 jeremybenn
  const struct eh_frame_array_ent *p = (const struct eh_frame_array_ent *) a;
1634
  const struct eh_frame_array_ent *q = (const struct eh_frame_array_ent *) b;
1635 24 jeremybenn
  if (p->initial_loc > q->initial_loc)
1636
    return 1;
1637
  if (p->initial_loc < q->initial_loc)
1638
    return -1;
1639
  return 0;
1640
}
1641
 
1642
/* Write out .eh_frame_hdr section.  This must be called after
1643
   _bfd_elf_write_section_eh_frame has been called on all input
1644
   .eh_frame sections.
1645
   .eh_frame_hdr format:
1646
   ubyte version                (currently 1)
1647
   ubyte eh_frame_ptr_enc       (DW_EH_PE_* encoding of pointer to start of
1648
                                 .eh_frame section)
1649
   ubyte fde_count_enc          (DW_EH_PE_* encoding of total FDE count
1650
                                 number (or DW_EH_PE_omit if there is no
1651
                                 binary search table computed))
1652
   ubyte table_enc              (DW_EH_PE_* encoding of binary search table,
1653
                                 or DW_EH_PE_omit if not present.
1654
                                 DW_EH_PE_datarel is using address of
1655
                                 .eh_frame_hdr section start as base)
1656
   [encoded] eh_frame_ptr       (pointer to start of .eh_frame section)
1657
   optionally followed by:
1658
   [encoded] fde_count          (total number of FDEs in .eh_frame section)
1659
   fde_count x [encoded] initial_loc, fde
1660
                                (array of encoded pairs containing
1661
                                 FDE initial_location field and FDE address,
1662
                                 sorted by increasing initial_loc).  */
1663
 
1664
bfd_boolean
1665
_bfd_elf_write_section_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info)
1666
{
1667
  struct elf_link_hash_table *htab;
1668
  struct eh_frame_hdr_info *hdr_info;
1669
  asection *sec;
1670
  bfd_byte *contents;
1671
  asection *eh_frame_sec;
1672
  bfd_size_type size;
1673
  bfd_boolean retval;
1674
  bfd_vma encoded_eh_frame;
1675
 
1676
  htab = elf_hash_table (info);
1677
  hdr_info = &htab->eh_info;
1678
  sec = hdr_info->hdr_sec;
1679
  if (sec == NULL)
1680
    return TRUE;
1681
 
1682
  size = EH_FRAME_HDR_SIZE;
1683
  if (hdr_info->array && hdr_info->array_count == hdr_info->fde_count)
1684
    size += 4 + hdr_info->fde_count * 8;
1685 225 jeremybenn
  contents = (bfd_byte *) bfd_malloc (size);
1686 24 jeremybenn
  if (contents == NULL)
1687
    return FALSE;
1688
 
1689
  eh_frame_sec = bfd_get_section_by_name (abfd, ".eh_frame");
1690
  if (eh_frame_sec == NULL)
1691
    {
1692
      free (contents);
1693
      return FALSE;
1694
    }
1695
 
1696
  memset (contents, 0, EH_FRAME_HDR_SIZE);
1697
  contents[0] = 1;                               /* Version.  */
1698
  contents[1] = get_elf_backend_data (abfd)->elf_backend_encode_eh_address
1699
    (abfd, info, eh_frame_sec, 0, sec, 4,
1700
     &encoded_eh_frame);                        /* .eh_frame offset.  */
1701
 
1702
  if (hdr_info->array && hdr_info->array_count == hdr_info->fde_count)
1703
    {
1704
      contents[2] = DW_EH_PE_udata4;            /* FDE count encoding.  */
1705
      contents[3] = DW_EH_PE_datarel | DW_EH_PE_sdata4; /* Search table enc.  */
1706
    }
1707
  else
1708
    {
1709
      contents[2] = DW_EH_PE_omit;
1710
      contents[3] = DW_EH_PE_omit;
1711
    }
1712
  bfd_put_32 (abfd, encoded_eh_frame, contents + 4);
1713
 
1714
  if (contents[2] != DW_EH_PE_omit)
1715
    {
1716
      unsigned int i;
1717
 
1718
      bfd_put_32 (abfd, hdr_info->fde_count, contents + EH_FRAME_HDR_SIZE);
1719
      qsort (hdr_info->array, hdr_info->fde_count, sizeof (*hdr_info->array),
1720
             vma_compare);
1721
      for (i = 0; i < hdr_info->fde_count; i++)
1722
        {
1723
          bfd_put_32 (abfd,
1724
                      hdr_info->array[i].initial_loc
1725
                      - sec->output_section->vma,
1726
                      contents + EH_FRAME_HDR_SIZE + i * 8 + 4);
1727
          bfd_put_32 (abfd,
1728
                      hdr_info->array[i].fde - sec->output_section->vma,
1729
                      contents + EH_FRAME_HDR_SIZE + i * 8 + 8);
1730
        }
1731
    }
1732
 
1733 225 jeremybenn
  /* FIXME: octets_per_byte.  */
1734 24 jeremybenn
  retval = bfd_set_section_contents (abfd, sec->output_section,
1735
                                     contents, (file_ptr) sec->output_offset,
1736
                                     sec->size);
1737
  free (contents);
1738
  return retval;
1739
}
1740
 
1741
/* Return the width of FDE addresses.  This is the default implementation.  */
1742
 
1743
unsigned int
1744
_bfd_elf_eh_frame_address_size (bfd *abfd, asection *sec ATTRIBUTE_UNUSED)
1745
{
1746
  return elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64 ? 8 : 4;
1747
}
1748
 
1749
/* Decide whether we can use a PC-relative encoding within the given
1750
   EH frame section.  This is the default implementation.  */
1751
 
1752
bfd_boolean
1753
_bfd_elf_can_make_relative (bfd *input_bfd ATTRIBUTE_UNUSED,
1754
                            struct bfd_link_info *info ATTRIBUTE_UNUSED,
1755
                            asection *eh_frame_section ATTRIBUTE_UNUSED)
1756
{
1757
  return TRUE;
1758
}
1759
 
1760
/* Select an encoding for the given address.  Preference is given to
1761
   PC-relative addressing modes.  */
1762
 
1763
bfd_byte
1764
_bfd_elf_encode_eh_address (bfd *abfd ATTRIBUTE_UNUSED,
1765
                            struct bfd_link_info *info ATTRIBUTE_UNUSED,
1766
                            asection *osec, bfd_vma offset,
1767
                            asection *loc_sec, bfd_vma loc_offset,
1768
                            bfd_vma *encoded)
1769
{
1770
  *encoded = osec->vma + offset -
1771
    (loc_sec->output_section->vma + loc_sec->output_offset + loc_offset);
1772
  return DW_EH_PE_pcrel | DW_EH_PE_sdata4;
1773
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.