daily update
[binutils.git] / gas / ehopt.c
blob048bc57b5a09f5fbcee50e93ab90e086a9571993
1 /* ehopt.c--optimize gcc exception frame information.
2 Copyright 1998, 2000, 2001, 2003, 2005, 2007 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 3, or (at your option)
10 any later version.
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, 51 Franklin Street - Fifth Floor, Boston, MA
20 02110-1301, USA. */
22 #include "as.h"
23 #include "subsegs.h"
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:
37 __FRAME_BEGIN__:
38 .4byte .LLCIE1 / Length of Common Information Entry
39 .LSCIE1:
40 #if .eh_frame
41 .4byte 0x0 / CIE Identifier Tag
42 #elif .debug_frame
43 .4byte 0xffffffff / CIE Identifier Tag
44 #endif
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
55 .align 4
56 .LECIE1:
57 .set .LLCIE1,.LECIE1-.LSCIE1 / CIE Length Symbol
58 .4byte .LLFDE1 / FDE Length
59 .LSFDE1:
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
64 .4byte .LCFI0-.LFB1
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
70 .4byte .LCFI1-.LCFI0
71 .byte 0xd / DW_CFA_def_cfa_register
72 .byte 0x5 / ULEB128 0x5
73 .byte 0x4 / DW_CFA_advance_loc4
74 .4byte .LCFI2-.LCFI1
75 .byte 0x2e / DW_CFA_GNU_args_size
76 .byte 0x4 / ULEB128 0x4
77 .byte 0x4 / DW_CFA_advance_loc4
78 .4byte .LCFI3-.LCFI2
79 .byte 0x2e / DW_CFA_GNU_args_size
80 .byte 0x0 / ULEB128 0x0
81 .align 4
82 .LEFDE1:
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. */
91 struct cie_info
93 unsigned code_alignment;
94 int z_augmentation;
97 static int get_cie_info (struct cie_info *);
99 /* Extract information from the CIE. */
101 static int
102 get_cie_info (struct cie_info *info)
104 fragS *f;
105 fixS *fix;
106 int offset;
107 char CIE_id;
108 char augmentation[10];
109 int iaug;
110 int code_alignment = 0;
112 /* We should find the CIE at the start of the section. */
114 f = seg_info (now_seg)->frchainP->frch_root;
115 fix = seg_info (now_seg)->frchainP->fix_root;
117 /* Look through the frags of the section to find the code alignment. */
119 /* First make sure that the CIE Identifier Tag is 0/-1. */
121 if (strcmp (segment_name (now_seg), ".debug_frame") == 0)
122 CIE_id = (char)0xff;
123 else
124 CIE_id = 0;
126 offset = 4;
127 while (f != NULL && offset >= f->fr_fix)
129 offset -= f->fr_fix;
130 f = f->fr_next;
132 if (f == NULL
133 || f->fr_fix - offset < 4
134 || f->fr_literal[offset] != CIE_id
135 || f->fr_literal[offset + 1] != CIE_id
136 || f->fr_literal[offset + 2] != CIE_id
137 || f->fr_literal[offset + 3] != CIE_id)
138 return 0;
140 /* Next make sure the CIE version number is 1. */
142 offset += 4;
143 while (f != NULL && offset >= f->fr_fix)
145 offset -= f->fr_fix;
146 f = f->fr_next;
148 if (f == NULL
149 || f->fr_fix - offset < 1
150 || f->fr_literal[offset] != 1)
151 return 0;
153 /* Skip the augmentation (a null terminated string). */
155 iaug = 0;
156 ++offset;
157 while (1)
159 while (f != NULL && offset >= f->fr_fix)
161 offset -= f->fr_fix;
162 f = f->fr_next;
164 if (f == NULL)
165 return 0;
167 while (offset < f->fr_fix && f->fr_literal[offset] != '\0')
169 if ((size_t) iaug < (sizeof augmentation) - 1)
171 augmentation[iaug] = f->fr_literal[offset];
172 ++iaug;
174 ++offset;
176 if (offset < f->fr_fix)
177 break;
179 ++offset;
180 while (f != NULL && offset >= f->fr_fix)
182 offset -= f->fr_fix;
183 f = f->fr_next;
185 if (f == NULL)
186 return 0;
188 augmentation[iaug] = '\0';
189 if (augmentation[0] == '\0')
191 /* No augmentation. */
193 else if (strcmp (augmentation, "eh") == 0)
195 /* We have to skip a pointer. Unfortunately, we don't know how
196 large it is. We find out by looking for a matching fixup. */
197 while (fix != NULL
198 && (fix->fx_frag != f || fix->fx_where != offset))
199 fix = fix->fx_next;
200 if (fix == NULL)
201 offset += 4;
202 else
203 offset += fix->fx_size;
204 while (f != NULL && offset >= f->fr_fix)
206 offset -= f->fr_fix;
207 f = f->fr_next;
209 if (f == NULL)
210 return 0;
212 else if (augmentation[0] != 'z')
213 return 0;
215 /* We're now at the code alignment factor, which is a ULEB128. If
216 it isn't a single byte, forget it. */
218 code_alignment = f->fr_literal[offset] & 0xff;
219 if ((code_alignment & 0x80) != 0)
220 code_alignment = 0;
222 info->code_alignment = code_alignment;
223 info->z_augmentation = (augmentation[0] == 'z');
225 return 1;
228 /* This function is called from emit_expr. It looks for cases which
229 we can optimize.
231 Rather than try to parse all this information as we read it, we
232 look for a single byte DW_CFA_advance_loc4 followed by a 4 byte
233 difference. We turn that into a rs_cfa_advance frag, and handle
234 those frags at the end of the assembly. If the gcc output changes
235 somewhat, this optimization may stop working.
237 This function returns non-zero if it handled the expression and
238 emit_expr should not do anything, or zero otherwise. It can also
239 change *EXP and *PNBYTES. */
242 check_eh_frame (expressionS *exp, unsigned int *pnbytes)
244 struct frame_data
246 enum frame_state
248 state_idle,
249 state_saw_size,
250 state_saw_cie_offset,
251 state_saw_pc_begin,
252 state_seeing_aug_size,
253 state_skipping_aug,
254 state_wait_loc4,
255 state_saw_loc4,
256 state_error,
257 } state;
259 int cie_info_ok;
260 struct cie_info cie_info;
262 symbolS *size_end_sym;
263 fragS *loc4_frag;
264 int loc4_fix;
266 int aug_size;
267 int aug_shift;
270 static struct frame_data eh_frame_data;
271 static struct frame_data debug_frame_data;
272 struct frame_data *d;
274 /* Don't optimize. */
275 if (flag_traditional_format)
276 return 0;
278 #ifdef md_allow_eh_opt
279 if (! md_allow_eh_opt)
280 return 0;
281 #endif
283 /* Select the proper section data. */
284 if (strcmp (segment_name (now_seg), ".eh_frame") == 0)
285 d = &eh_frame_data;
286 else if (strcmp (segment_name (now_seg), ".debug_frame") == 0)
287 d = &debug_frame_data;
288 else
289 return 0;
291 if (d->state >= state_saw_size && S_IS_DEFINED (d->size_end_sym))
293 /* We have come to the end of the CIE or FDE. See below where
294 we set saw_size. We must check this first because we may now
295 be looking at the next size. */
296 d->state = state_idle;
299 switch (d->state)
301 case state_idle:
302 if (*pnbytes == 4)
304 /* This might be the size of the CIE or FDE. We want to know
305 the size so that we don't accidentally optimize across an FDE
306 boundary. We recognize the size in one of two forms: a
307 symbol which will later be defined as a difference, or a
308 subtraction of two symbols. Either way, we can tell when we
309 are at the end of the FDE because the symbol becomes defined
310 (in the case of a subtraction, the end symbol, from which the
311 start symbol is being subtracted). Other ways of describing
312 the size will not be optimized. */
313 if ((exp->X_op == O_symbol || exp->X_op == O_subtract)
314 && ! S_IS_DEFINED (exp->X_add_symbol))
316 d->state = state_saw_size;
317 d->size_end_sym = exp->X_add_symbol;
320 break;
322 case state_saw_size:
323 case state_saw_cie_offset:
324 /* Assume whatever form it appears in, it appears atomically. */
325 d->state += 1;
326 break;
328 case state_saw_pc_begin:
329 /* Decide whether we should see an augmentation. */
330 if (! d->cie_info_ok
331 && ! (d->cie_info_ok = get_cie_info (&d->cie_info)))
332 d->state = state_error;
333 else if (d->cie_info.z_augmentation)
335 d->state = state_seeing_aug_size;
336 d->aug_size = 0;
337 d->aug_shift = 0;
339 else
340 d->state = state_wait_loc4;
341 break;
343 case state_seeing_aug_size:
344 /* Bytes == -1 means this comes from an leb128 directive. */
345 if ((int)*pnbytes == -1 && exp->X_op == O_constant)
347 d->aug_size = exp->X_add_number;
348 d->state = state_skipping_aug;
350 else if (*pnbytes == 1 && exp->X_op == O_constant)
352 unsigned char byte = exp->X_add_number;
353 d->aug_size |= (byte & 0x7f) << d->aug_shift;
354 d->aug_shift += 7;
355 if ((byte & 0x80) == 0)
356 d->state = state_skipping_aug;
358 else
359 d->state = state_error;
360 if (d->state == state_skipping_aug && d->aug_size == 0)
361 d->state = state_wait_loc4;
362 break;
364 case state_skipping_aug:
365 if ((int)*pnbytes < 0)
366 d->state = state_error;
367 else
369 int left = (d->aug_size -= *pnbytes);
370 if (left == 0)
371 d->state = state_wait_loc4;
372 else if (left < 0)
373 d->state = state_error;
375 break;
377 case state_wait_loc4:
378 if (*pnbytes == 1
379 && exp->X_op == O_constant
380 && exp->X_add_number == DW_CFA_advance_loc4)
382 /* This might be a DW_CFA_advance_loc4. Record the frag and the
383 position within the frag, so that we can change it later. */
384 frag_grow (1);
385 d->state = state_saw_loc4;
386 d->loc4_frag = frag_now;
387 d->loc4_fix = frag_now_fix ();
389 break;
391 case state_saw_loc4:
392 d->state = state_wait_loc4;
393 if (*pnbytes != 4)
394 break;
395 if (exp->X_op == O_constant)
397 /* This is a case which we can optimize. The two symbols being
398 subtracted were in the same frag and the expression was
399 reduced to a constant. We can do the optimization entirely
400 in this function. */
401 if (d->cie_info.code_alignment > 0
402 && exp->X_add_number % d->cie_info.code_alignment == 0
403 && exp->X_add_number / d->cie_info.code_alignment < 0x40)
405 d->loc4_frag->fr_literal[d->loc4_fix]
406 = DW_CFA_advance_loc
407 | (exp->X_add_number / d->cie_info.code_alignment);
408 /* No more bytes needed. */
409 return 1;
411 else if (exp->X_add_number < 0x100)
413 d->loc4_frag->fr_literal[d->loc4_fix] = DW_CFA_advance_loc1;
414 *pnbytes = 1;
416 else if (exp->X_add_number < 0x10000)
418 d->loc4_frag->fr_literal[d->loc4_fix] = DW_CFA_advance_loc2;
419 *pnbytes = 2;
422 else if (exp->X_op == O_subtract)
424 /* This is a case we can optimize. The expression was not
425 reduced, so we can not finish the optimization until the end
426 of the assembly. We set up a variant frag which we handle
427 later. */
428 int fr_subtype;
430 if (d->cie_info.code_alignment > 0)
431 fr_subtype = d->cie_info.code_alignment << 3;
432 else
433 fr_subtype = 0;
435 frag_var (rs_cfa, 4, 0, fr_subtype, make_expr_symbol (exp),
436 d->loc4_fix, (char *) d->loc4_frag);
437 return 1;
439 break;
441 case state_error:
442 /* Just skipping everything. */
443 break;
446 return 0;
449 /* The function estimates the size of a rs_cfa variant frag based on
450 the current values of the symbols. It is called before the
451 relaxation loop. We set fr_subtype{0:2} to the expected length. */
454 eh_frame_estimate_size_before_relax (fragS *frag)
456 offsetT diff;
457 int ca = frag->fr_subtype >> 3;
458 int ret;
460 diff = resolve_symbol_value (frag->fr_symbol);
462 if (ca > 0 && diff % ca == 0 && diff / ca < 0x40)
463 ret = 0;
464 else if (diff < 0x100)
465 ret = 1;
466 else if (diff < 0x10000)
467 ret = 2;
468 else
469 ret = 4;
471 frag->fr_subtype = (frag->fr_subtype & ~7) | ret;
473 return ret;
476 /* This function relaxes a rs_cfa variant frag based on the current
477 values of the symbols. fr_subtype{0:2} is the current length of
478 the frag. This returns the change in frag length. */
481 eh_frame_relax_frag (fragS *frag)
483 int oldsize, newsize;
485 oldsize = frag->fr_subtype & 7;
486 newsize = eh_frame_estimate_size_before_relax (frag);
487 return newsize - oldsize;
490 /* This function converts a rs_cfa variant frag into a normal fill
491 frag. This is called after all relaxation has been done.
492 fr_subtype{0:2} will be the desired length of the frag. */
494 void
495 eh_frame_convert_frag (fragS *frag)
497 offsetT diff;
498 fragS *loc4_frag;
499 int loc4_fix;
501 loc4_frag = (fragS *) frag->fr_opcode;
502 loc4_fix = (int) frag->fr_offset;
504 diff = resolve_symbol_value (frag->fr_symbol);
506 switch (frag->fr_subtype & 7)
508 case 0:
510 int ca = frag->fr_subtype >> 3;
511 assert (ca > 0 && diff % ca == 0 && diff / ca < 0x40);
512 loc4_frag->fr_literal[loc4_fix] = DW_CFA_advance_loc | (diff / ca);
514 break;
516 case 1:
517 assert (diff < 0x100);
518 loc4_frag->fr_literal[loc4_fix] = DW_CFA_advance_loc1;
519 frag->fr_literal[frag->fr_fix] = diff;
520 break;
522 case 2:
523 assert (diff < 0x10000);
524 loc4_frag->fr_literal[loc4_fix] = DW_CFA_advance_loc2;
525 md_number_to_chars (frag->fr_literal + frag->fr_fix, diff, 2);
526 break;
528 default:
529 md_number_to_chars (frag->fr_literal + frag->fr_fix, diff, 4);
530 break;
533 frag->fr_fix += frag->fr_subtype & 7;
534 frag->fr_type = rs_fill;
535 frag->fr_subtype = 0;
536 frag->fr_offset = 0;