1 /* ehopt.c--optimize gcc exception frame information.
2 Copyright 1998, 2000, 2001, 2003, 2005, 2007, 2008
3 Free Software Foundation, Inc.
4 Written by Ian Lance Taylor <ian@cygnus.com>.
6 This file is part of GAS, the GNU Assembler.
8 GAS 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, or (at your option)
13 GAS 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.
18 You should have received a copy of the GNU General Public License
19 along with GAS; see the file COPYING. If not, write to the Free
20 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
25 #include "struc-symbol.h"
27 /* We include this ELF file, even though we may not be assembling for
28 ELF, since the exception frame information is always in a format
29 derived from DWARF. */
33 /* Try to optimize gcc 2.8 exception frame information.
35 Exception frame information is emitted for every function in the
36 .eh_frame or .debug_frame sections. Simple information for a function
37 with no exceptions looks like this:
40 .4byte .LLCIE1 / Length of Common Information Entry
43 .4byte 0x0 / CIE Identifier Tag
45 .4byte 0xffffffff / CIE Identifier Tag
47 .byte 0x1 / CIE Version
48 .byte 0x0 / CIE Augmentation (none)
49 .byte 0x1 / ULEB128 0x1 (CIE Code Alignment Factor)
50 .byte 0x7c / SLEB128 -4 (CIE Data Alignment Factor)
51 .byte 0x8 / CIE RA Column
52 .byte 0xc / DW_CFA_def_cfa
53 .byte 0x4 / ULEB128 0x4
54 .byte 0x4 / ULEB128 0x4
55 .byte 0x88 / DW_CFA_offset, column 0x8
56 .byte 0x1 / ULEB128 0x1
59 .set .LLCIE1,.LECIE1-.LSCIE1 / CIE Length Symbol
60 .4byte .LLFDE1 / FDE Length
62 .4byte .LSFDE1-__FRAME_BEGIN__ / FDE CIE offset
63 .4byte .LFB1 / FDE initial location
64 .4byte .LFE1-.LFB1 / FDE address range
65 .byte 0x4 / DW_CFA_advance_loc4
67 .byte 0xe / DW_CFA_def_cfa_offset
68 .byte 0x8 / ULEB128 0x8
69 .byte 0x85 / DW_CFA_offset, column 0x5
70 .byte 0x2 / ULEB128 0x2
71 .byte 0x4 / DW_CFA_advance_loc4
73 .byte 0xd / DW_CFA_def_cfa_register
74 .byte 0x5 / ULEB128 0x5
75 .byte 0x4 / DW_CFA_advance_loc4
77 .byte 0x2e / DW_CFA_GNU_args_size
78 .byte 0x4 / ULEB128 0x4
79 .byte 0x4 / DW_CFA_advance_loc4
81 .byte 0x2e / DW_CFA_GNU_args_size
82 .byte 0x0 / ULEB128 0x0
85 .set .LLFDE1,.LEFDE1-.LSFDE1 / FDE Length Symbol
87 The immediate issue we can address in the assembler is the
88 DW_CFA_advance_loc4 followed by a four byte value. The value is
89 the difference of two addresses in the function. Since gcc does
90 not know this value, it always uses four bytes. We will know the
91 value at the end of assembly, so we can do better. */
95 unsigned code_alignment;
99 static int get_cie_info (struct cie_info *);
101 /* Extract information from the CIE. */
104 get_cie_info (struct cie_info *info)
110 char augmentation[10];
112 int code_alignment = 0;
114 /* We should find the CIE at the start of the section. */
116 f = seg_info (now_seg)->frchainP->frch_root;
117 fix = seg_info (now_seg)->frchainP->fix_root;
119 /* Look through the frags of the section to find the code alignment. */
121 /* First make sure that the CIE Identifier Tag is 0/-1. */
123 if (strcmp (segment_name (now_seg), ".debug_frame") == 0)
129 while (f != NULL && offset >= f->fr_fix)
135 || f->fr_fix - offset < 4
136 || f->fr_literal[offset] != CIE_id
137 || f->fr_literal[offset + 1] != CIE_id
138 || f->fr_literal[offset + 2] != CIE_id
139 || f->fr_literal[offset + 3] != CIE_id)
142 /* Next make sure the CIE version number is 1. */
145 while (f != NULL && offset >= f->fr_fix)
151 || f->fr_fix - offset < 1
152 || f->fr_literal[offset] != 1)
155 /* Skip the augmentation (a null terminated string). */
161 while (f != NULL && offset >= f->fr_fix)
169 while (offset < f->fr_fix && f->fr_literal[offset] != '\0')
171 if ((size_t) iaug < (sizeof augmentation) - 1)
173 augmentation[iaug] = f->fr_literal[offset];
178 if (offset < f->fr_fix)
182 while (f != NULL && offset >= f->fr_fix)
190 augmentation[iaug] = '\0';
191 if (augmentation[0] == '\0')
193 /* No augmentation. */
195 else if (strcmp (augmentation, "eh") == 0)
197 /* We have to skip a pointer. Unfortunately, we don't know how
198 large it is. We find out by looking for a matching fixup. */
200 && (fix->fx_frag != f || fix->fx_where != offset))
205 offset += fix->fx_size;
206 while (f != NULL && offset >= f->fr_fix)
214 else if (augmentation[0] != 'z')
217 /* We're now at the code alignment factor, which is a ULEB128. If
218 it isn't a single byte, forget it. */
220 code_alignment = f->fr_literal[offset] & 0xff;
221 if ((code_alignment & 0x80) != 0)
224 info->code_alignment = code_alignment;
225 info->z_augmentation = (augmentation[0] == 'z');
230 /* This function is called from emit_expr. It looks for cases which
233 Rather than try to parse all this information as we read it, we
234 look for a single byte DW_CFA_advance_loc4 followed by a 4 byte
235 difference. We turn that into a rs_cfa_advance frag, and handle
236 those frags at the end of the assembly. If the gcc output changes
237 somewhat, this optimization may stop working.
239 This function returns non-zero if it handled the expression and
240 emit_expr should not do anything, or zero otherwise. It can also
241 change *EXP and *PNBYTES. */
244 check_eh_frame (expressionS *exp, unsigned int *pnbytes)
252 state_saw_cie_offset,
254 state_seeing_aug_size,
262 struct cie_info cie_info;
264 symbolS *size_end_sym;
272 static struct frame_data eh_frame_data;
273 static struct frame_data debug_frame_data;
274 struct frame_data *d;
276 /* Don't optimize. */
277 if (flag_traditional_format)
280 #ifdef md_allow_eh_opt
281 if (! md_allow_eh_opt)
285 /* Select the proper section data. */
286 if (strcmp (segment_name (now_seg), ".eh_frame") == 0)
288 else if (strcmp (segment_name (now_seg), ".debug_frame") == 0)
289 d = &debug_frame_data;
293 if (d->state >= state_saw_size && S_IS_DEFINED (d->size_end_sym))
295 /* We have come to the end of the CIE or FDE. See below where
296 we set saw_size. We must check this first because we may now
297 be looking at the next size. */
298 d->state = state_idle;
306 /* This might be the size of the CIE or FDE. We want to know
307 the size so that we don't accidentally optimize across an FDE
308 boundary. We recognize the size in one of two forms: a
309 symbol which will later be defined as a difference, or a
310 subtraction of two symbols. Either way, we can tell when we
311 are at the end of the FDE because the symbol becomes defined
312 (in the case of a subtraction, the end symbol, from which the
313 start symbol is being subtracted). Other ways of describing
314 the size will not be optimized. */
315 if ((exp->X_op == O_symbol || exp->X_op == O_subtract)
316 && ! S_IS_DEFINED (exp->X_add_symbol))
318 d->state = state_saw_size;
319 d->size_end_sym = exp->X_add_symbol;
325 case state_saw_cie_offset:
326 /* Assume whatever form it appears in, it appears atomically. */
330 case state_saw_pc_begin:
331 /* Decide whether we should see an augmentation. */
333 && ! (d->cie_info_ok = get_cie_info (&d->cie_info)))
334 d->state = state_error;
335 else if (d->cie_info.z_augmentation)
337 d->state = state_seeing_aug_size;
342 d->state = state_wait_loc4;
345 case state_seeing_aug_size:
346 /* Bytes == -1 means this comes from an leb128 directive. */
347 if ((int)*pnbytes == -1 && exp->X_op == O_constant)
349 d->aug_size = exp->X_add_number;
350 d->state = state_skipping_aug;
352 else if (*pnbytes == 1 && exp->X_op == O_constant)
354 unsigned char byte = exp->X_add_number;
355 d->aug_size |= (byte & 0x7f) << d->aug_shift;
357 if ((byte & 0x80) == 0)
358 d->state = state_skipping_aug;
361 d->state = state_error;
362 if (d->state == state_skipping_aug && d->aug_size == 0)
363 d->state = state_wait_loc4;
366 case state_skipping_aug:
367 if ((int)*pnbytes < 0)
368 d->state = state_error;
371 int left = (d->aug_size -= *pnbytes);
373 d->state = state_wait_loc4;
375 d->state = state_error;
379 case state_wait_loc4:
381 && exp->X_op == O_constant
382 && exp->X_add_number == DW_CFA_advance_loc4)
384 /* This might be a DW_CFA_advance_loc4. Record the frag and the
385 position within the frag, so that we can change it later. */
387 d->state = state_saw_loc4;
388 d->loc4_frag = frag_now;
389 d->loc4_fix = frag_now_fix ();
394 d->state = state_wait_loc4;
397 if (exp->X_op == O_constant)
399 /* This is a case which we can optimize. The two symbols being
400 subtracted were in the same frag and the expression was
401 reduced to a constant. We can do the optimization entirely
403 if (exp->X_add_number < 0x40)
405 d->loc4_frag->fr_literal[d->loc4_fix]
406 = DW_CFA_advance_loc | exp->X_add_number;
407 /* No more bytes needed. */
410 else if (exp->X_add_number < 0x100)
412 d->loc4_frag->fr_literal[d->loc4_fix] = DW_CFA_advance_loc1;
415 else if (exp->X_add_number < 0x10000)
417 d->loc4_frag->fr_literal[d->loc4_fix] = DW_CFA_advance_loc2;
421 else if (exp->X_op == O_subtract && d->cie_info.code_alignment == 1)
423 /* This is a case we can optimize. The expression was not
424 reduced, so we can not finish the optimization until the end
425 of the assembly. We set up a variant frag which we handle
427 frag_var (rs_cfa, 4, 0, 1 << 3, make_expr_symbol (exp),
428 d->loc4_fix, (char *) d->loc4_frag);
431 else if ((exp->X_op == O_divide
432 || exp->X_op == O_right_shift)
433 && d->cie_info.code_alignment > 1)
435 if (exp->X_add_symbol->bsym
436 && exp->X_op_symbol->bsym
437 && exp->X_add_symbol->sy_value.X_op == O_subtract
438 && exp->X_op_symbol->sy_value.X_op == O_constant
439 && ((exp->X_op == O_divide
440 ? exp->X_op_symbol->sy_value.X_add_number
441 : (offsetT) 1 << exp->X_op_symbol->sy_value.X_add_number)
442 == (offsetT) d->cie_info.code_alignment))
444 /* This is a case we can optimize as well. The expression was
445 not reduced, so we can not finish the optimization until the
446 end of the assembly. We set up a variant frag which we
448 frag_var (rs_cfa, 4, 0, d->cie_info.code_alignment << 3,
449 make_expr_symbol (&exp->X_add_symbol->sy_value),
450 d->loc4_fix, (char *) d->loc4_frag);
457 /* Just skipping everything. */
464 /* The function estimates the size of a rs_cfa variant frag based on
465 the current values of the symbols. It is called before the
466 relaxation loop. We set fr_subtype{0:2} to the expected length. */
469 eh_frame_estimate_size_before_relax (fragS *frag)
472 int ca = frag->fr_subtype >> 3;
475 diff = resolve_symbol_value (frag->fr_symbol);
481 else if (diff < 0x100)
483 else if (diff < 0x10000)
488 frag->fr_subtype = (frag->fr_subtype & ~7) | ret;
493 /* This function relaxes a rs_cfa variant frag based on the current
494 values of the symbols. fr_subtype{0:2} is the current length of
495 the frag. This returns the change in frag length. */
498 eh_frame_relax_frag (fragS *frag)
500 int oldsize, newsize;
502 oldsize = frag->fr_subtype & 7;
503 newsize = eh_frame_estimate_size_before_relax (frag);
504 return newsize - oldsize;
507 /* This function converts a rs_cfa variant frag into a normal fill
508 frag. This is called after all relaxation has been done.
509 fr_subtype{0:2} will be the desired length of the frag. */
512 eh_frame_convert_frag (fragS *frag)
518 loc4_frag = (fragS *) frag->fr_opcode;
519 loc4_fix = (int) frag->fr_offset;
521 diff = resolve_symbol_value (frag->fr_symbol);
523 ca = frag->fr_subtype >> 3;
526 switch (frag->fr_subtype & 7)
529 gas_assert (diff < 0x40);
530 loc4_frag->fr_literal[loc4_fix] = DW_CFA_advance_loc | diff;
534 gas_assert (diff < 0x100);
535 loc4_frag->fr_literal[loc4_fix] = DW_CFA_advance_loc1;
536 frag->fr_literal[frag->fr_fix] = diff;
540 gas_assert (diff < 0x10000);
541 loc4_frag->fr_literal[loc4_fix] = DW_CFA_advance_loc2;
542 md_number_to_chars (frag->fr_literal + frag->fr_fix, diff, 2);
546 md_number_to_chars (frag->fr_literal + frag->fr_fix, diff, 4);
550 frag->fr_fix += frag->fr_subtype & 7;
551 frag->fr_type = rs_fill;
552 frag->fr_subtype = 0;