1 /* ehopt.c--optimize gcc exception frame information.
2 Copyright 1998, 2000, 2001 Free Software Foundation, Inc.
3 Written by Ian Lance Taylor <ian@cygnus.com>.
5 This file is part of GAS, the GNU Assembler.
7 GAS is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GAS is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GAS; see the file COPYING. If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
25 /* We include this ELF file, even though we may not be assembling for
26 ELF, since the exception frame information is always in a format
27 derived from DWARF. */
29 #include "elf/dwarf2.h"
31 /* Try to optimize gcc 2.8 exception frame information.
33 Exception frame information is emitted for every function in the
34 .eh_frame or .debug_frame sections. Simple information for a function
35 with no exceptions looks like this:
38 .4byte .LLCIE1 / Length of Common Information Entry
41 .4byte 0x0 / CIE Identifier Tag
43 .4byte 0xffffffff / CIE Identifier Tag
45 .byte 0x1 / CIE Version
46 .byte 0x0 / CIE Augmentation (none)
47 .byte 0x1 / ULEB128 0x1 (CIE Code Alignment Factor)
48 .byte 0x7c / SLEB128 -4 (CIE Data Alignment Factor)
49 .byte 0x8 / CIE RA Column
50 .byte 0xc / DW_CFA_def_cfa
51 .byte 0x4 / ULEB128 0x4
52 .byte 0x4 / ULEB128 0x4
53 .byte 0x88 / DW_CFA_offset, column 0x8
54 .byte 0x1 / ULEB128 0x1
57 .set .LLCIE1,.LECIE1-.LSCIE1 / CIE Length Symbol
58 .4byte .LLFDE1 / FDE Length
60 .4byte .LSFDE1-__FRAME_BEGIN__ / FDE CIE offset
61 .4byte .LFB1 / FDE initial location
62 .4byte .LFE1-.LFB1 / FDE address range
63 .byte 0x4 / DW_CFA_advance_loc4
65 .byte 0xe / DW_CFA_def_cfa_offset
66 .byte 0x8 / ULEB128 0x8
67 .byte 0x85 / DW_CFA_offset, column 0x5
68 .byte 0x2 / ULEB128 0x2
69 .byte 0x4 / DW_CFA_advance_loc4
71 .byte 0xd / DW_CFA_def_cfa_register
72 .byte 0x5 / ULEB128 0x5
73 .byte 0x4 / DW_CFA_advance_loc4
75 .byte 0x2e / DW_CFA_GNU_args_size
76 .byte 0x4 / ULEB128 0x4
77 .byte 0x4 / DW_CFA_advance_loc4
79 .byte 0x2e / DW_CFA_GNU_args_size
80 .byte 0x0 / ULEB128 0x0
83 .set .LLFDE1,.LEFDE1-.LSFDE1 / FDE Length Symbol
85 The immediate issue we can address in the assembler is the
86 DW_CFA_advance_loc4 followed by a four byte value. The value is
87 the difference of two addresses in the function. Since gcc does
88 not know this value, it always uses four bytes. We will know the
89 value at the end of assembly, so we can do better. */
93 unsigned code_alignment;
97 static int get_cie_info PARAMS ((struct cie_info *));
99 /* Extract information from the CIE. */
103 struct cie_info *info;
109 char augmentation[10];
111 int code_alignment = 0;
113 /* We should find the CIE at the start of the section. */
115 #if defined (BFD_ASSEMBLER) || defined (MANY_SEGMENTS)
116 f = seg_info (now_seg)->frchainP->frch_root;
118 f = frchain_now->frch_root;
121 fix = seg_info (now_seg)->frchainP->fix_root;
123 fix = *seg_fix_rootP;
126 /* Look through the frags of the section to find the code alignment. */
128 /* First make sure that the CIE Identifier Tag is 0/-1. */
130 if (strcmp (segment_name (now_seg), ".debug_frame") == 0)
136 while (f != NULL && offset >= f->fr_fix)
142 || f->fr_fix - offset < 4
143 || f->fr_literal[offset] != CIE_id
144 || f->fr_literal[offset + 1] != CIE_id
145 || f->fr_literal[offset + 2] != CIE_id
146 || f->fr_literal[offset + 3] != CIE_id)
149 /* Next make sure the CIE version number is 1. */
152 while (f != NULL && offset >= f->fr_fix)
158 || f->fr_fix - offset < 1
159 || f->fr_literal[offset] != 1)
162 /* Skip the augmentation (a null terminated string). */
168 while (f != NULL && offset >= f->fr_fix)
176 while (offset < f->fr_fix && f->fr_literal[offset] != '\0')
178 if ((size_t) iaug < (sizeof augmentation) - 1)
180 augmentation[iaug] = f->fr_literal[offset];
185 if (offset < f->fr_fix)
189 while (f != NULL && offset >= f->fr_fix)
197 augmentation[iaug] = '\0';
198 if (augmentation[0] == '\0')
200 /* No augmentation. */
202 else if (strcmp (augmentation, "eh") == 0)
204 /* We have to skip a pointer. Unfortunately, we don't know how
205 large it is. We find out by looking for a matching fixup. */
207 && (fix->fx_frag != f || fix->fx_where != offset))
212 offset += fix->fx_size;
213 while (f != NULL && offset >= f->fr_fix)
221 else if (augmentation[0] != 'z')
224 /* We're now at the code alignment factor, which is a ULEB128. If
225 it isn't a single byte, forget it. */
227 code_alignment = f->fr_literal[offset] & 0xff;
228 if ((code_alignment & 0x80) != 0)
231 info->code_alignment = code_alignment;
232 info->z_augmentation = (augmentation[0] == 'z');
237 /* This function is called from emit_expr. It looks for cases which
240 Rather than try to parse all this information as we read it, we
241 look for a single byte DW_CFA_advance_loc4 followed by a 4 byte
242 difference. We turn that into a rs_cfa_advance frag, and handle
243 those frags at the end of the assembly. If the gcc output changes
244 somewhat, this optimization may stop working.
246 This function returns non-zero if it handled the expression and
247 emit_expr should not do anything, or zero otherwise. It can also
248 change *EXP and *PNBYTES. */
251 check_eh_frame (exp, pnbytes)
253 unsigned int *pnbytes;
261 state_saw_cie_offset,
263 state_seeing_aug_size,
271 struct cie_info cie_info;
273 symbolS *size_end_sym;
281 static struct frame_data eh_frame_data;
282 static struct frame_data debug_frame_data;
283 struct frame_data *d;
285 /* Don't optimize. */
286 if (flag_traditional_format)
289 /* Select the proper section data. */
290 if (strcmp (segment_name (now_seg), ".eh_frame") == 0)
292 else if (strcmp (segment_name (now_seg), ".debug_frame") == 0)
293 d = &debug_frame_data;
297 if (d->state >= state_saw_size && S_IS_DEFINED (d->size_end_sym))
299 /* We have come to the end of the CIE or FDE. See below where
300 we set saw_size. We must check this first because we may now
301 be looking at the next size. */
302 d->state = state_idle;
310 /* This might be the size of the CIE or FDE. We want to know
311 the size so that we don't accidentally optimize across an FDE
312 boundary. We recognize the size in one of two forms: a
313 symbol which will later be defined as a difference, or a
314 subtraction of two symbols. Either way, we can tell when we
315 are at the end of the FDE because the symbol becomes defined
316 (in the case of a subtraction, the end symbol, from which the
317 start symbol is being subtracted). Other ways of describing
318 the size will not be optimized. */
319 if ((exp->X_op == O_symbol || exp->X_op == O_subtract)
320 && ! S_IS_DEFINED (exp->X_add_symbol))
322 d->state = state_saw_size;
323 d->size_end_sym = exp->X_add_symbol;
329 case state_saw_cie_offset:
330 /* Assume whatever form it appears in, it appears atomically. */
334 case state_saw_pc_begin:
335 /* Decide whether we should see an augmentation. */
337 && ! (d->cie_info_ok = get_cie_info (&d->cie_info)))
338 d->state = state_error;
339 else if (d->cie_info.z_augmentation)
341 d->state = state_seeing_aug_size;
346 d->state = state_wait_loc4;
349 case state_seeing_aug_size:
350 /* Bytes == -1 means this comes from an leb128 directive. */
351 if ((int)*pnbytes == -1 && exp->X_op == O_constant)
353 d->aug_size = exp->X_add_number;
354 d->state = state_skipping_aug;
356 else if (*pnbytes == 1 && exp->X_op == O_constant)
358 unsigned char byte = exp->X_add_number;
359 d->aug_size |= (byte & 0x7f) << d->aug_shift;
361 if ((byte & 0x80) == 0)
362 d->state = state_skipping_aug;
365 d->state = state_error;
368 case state_skipping_aug:
369 if ((int)*pnbytes < 0)
370 d->state = state_error;
373 int left = (d->aug_size -= *pnbytes);
375 d->state = state_wait_loc4;
377 d->state = state_error;
381 case state_wait_loc4:
383 && exp->X_op == O_constant
384 && exp->X_add_number == DW_CFA_advance_loc4)
386 /* This might be a DW_CFA_advance_loc4. Record the frag and the
387 position within the frag, so that we can change it later. */
389 d->state = state_saw_loc4;
390 d->loc4_frag = frag_now;
391 d->loc4_fix = frag_now_fix ();
396 d->state = state_wait_loc4;
399 if (exp->X_op == O_constant)
401 /* This is a case which we can optimize. The two symbols being
402 subtracted were in the same frag and the expression was
403 reduced to a constant. We can do the optimization entirely
405 if (d->cie_info.code_alignment > 0
406 && exp->X_add_number % d->cie_info.code_alignment == 0
407 && exp->X_add_number / d->cie_info.code_alignment < 0x40)
409 d->loc4_frag->fr_literal[d->loc4_fix]
411 | (exp->X_add_number / d->cie_info.code_alignment);
412 /* No more bytes needed. */
415 else if (exp->X_add_number < 0x100)
417 d->loc4_frag->fr_literal[d->loc4_fix] = DW_CFA_advance_loc1;
420 else if (exp->X_add_number < 0x10000)
422 d->loc4_frag->fr_literal[d->loc4_fix] = DW_CFA_advance_loc2;
426 else if (exp->X_op == O_subtract)
428 /* This is a case we can optimize. The expression was not
429 reduced, so we can not finish the optimization until the end
430 of the assembly. We set up a variant frag which we handle
434 if (d->cie_info.code_alignment > 0)
435 fr_subtype = d->cie_info.code_alignment << 3;
439 frag_var (rs_cfa, 4, 0, fr_subtype, make_expr_symbol (exp),
440 d->loc4_fix, (char *) d->loc4_frag);
446 /* Just skipping everything. */
453 /* The function estimates the size of a rs_cfa variant frag based on
454 the current values of the symbols. It is called before the
455 relaxation loop. We set fr_subtype{0:2} to the expected length. */
458 eh_frame_estimate_size_before_relax (frag)
462 int ca = frag->fr_subtype >> 3;
465 diff = resolve_symbol_value (frag->fr_symbol, 0);
467 if (ca > 0 && diff % ca == 0 && diff / ca < 0x40)
469 else if (diff < 0x100)
471 else if (diff < 0x10000)
476 frag->fr_subtype = (frag->fr_subtype & ~7) | ret;
481 /* This function relaxes a rs_cfa variant frag based on the current
482 values of the symbols. fr_subtype{0:2} is the current length of
483 the frag. This returns the change in frag length. */
486 eh_frame_relax_frag (frag)
489 int oldsize, newsize;
491 oldsize = frag->fr_subtype & 7;
492 newsize = eh_frame_estimate_size_before_relax (frag);
493 return newsize - oldsize;
496 /* This function converts a rs_cfa variant frag into a normal fill
497 frag. This is called after all relaxation has been done.
498 fr_subtype{0:2} will be the desired length of the frag. */
501 eh_frame_convert_frag (frag)
508 loc4_frag = (fragS *) frag->fr_opcode;
509 loc4_fix = (int) frag->fr_offset;
511 diff = resolve_symbol_value (frag->fr_symbol, finalize_syms);
513 switch (frag->fr_subtype & 7)
517 int ca = frag->fr_subtype >> 3;
518 assert (ca > 0 && diff % ca == 0 && diff / ca < 0x40);
519 loc4_frag->fr_literal[loc4_fix] = DW_CFA_advance_loc | (diff / ca);
524 assert (diff < 0x100);
525 loc4_frag->fr_literal[loc4_fix] = DW_CFA_advance_loc1;
526 frag->fr_literal[frag->fr_fix] = diff;
530 assert (diff < 0x10000);
531 loc4_frag->fr_literal[loc4_fix] = DW_CFA_advance_loc2;
532 md_number_to_chars (frag->fr_literal + frag->fr_fix, diff, 2);
536 md_number_to_chars (frag->fr_literal + frag->fr_fix, diff, 4);
540 frag->fr_fix += frag->fr_subtype & 7;
541 frag->fr_type = rs_fill;
542 frag->fr_subtype = 0;