1 /* ehopt.c--optimize gcc exception frame information.
2 Copyright (C) 1998 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 section. Simple information for a function with no
35 exceptions looks like this:
38 .4byte .LLCIE1 / Length of Common Information Entry
40 .4byte 0x0 / CIE Identifier Tag
41 .byte 0x1 / CIE Version
42 .byte 0x0 / CIE Augmentation (none)
43 .byte 0x1 / ULEB128 0x1 (CIE Code Alignment Factor)
44 .byte 0x7c / SLEB128 -4 (CIE Data Alignment Factor)
45 .byte 0x8 / CIE RA Column
46 .byte 0xc / DW_CFA_def_cfa
47 .byte 0x4 / ULEB128 0x4
48 .byte 0x4 / ULEB128 0x4
49 .byte 0x88 / DW_CFA_offset, column 0x8
50 .byte 0x1 / ULEB128 0x1
53 .set .LLCIE1,.LECIE1-.LSCIE1 / CIE Length Symbol
54 .4byte .LLFDE1 / FDE Length
56 .4byte .LSFDE1-__FRAME_BEGIN__ / FDE CIE offset
57 .4byte .LFB1 / FDE initial location
58 .4byte .LFE1-.LFB1 / FDE address range
59 .byte 0x4 / DW_CFA_advance_loc4
61 .byte 0xe / DW_CFA_def_cfa_offset
62 .byte 0x8 / ULEB128 0x8
63 .byte 0x85 / DW_CFA_offset, column 0x5
64 .byte 0x2 / ULEB128 0x2
65 .byte 0x4 / DW_CFA_advance_loc4
67 .byte 0xd / DW_CFA_def_cfa_register
68 .byte 0x5 / ULEB128 0x5
69 .byte 0x4 / DW_CFA_advance_loc4
71 .byte 0x2e / DW_CFA_GNU_args_size
72 .byte 0x4 / ULEB128 0x4
73 .byte 0x4 / DW_CFA_advance_loc4
75 .byte 0x2e / DW_CFA_GNU_args_size
76 .byte 0x0 / ULEB128 0x0
79 .set .LLFDE1,.LEFDE1-.LSFDE1 / FDE Length Symbol
81 The immediate issue we can address in the assembler is the
82 DW_CFA_advance_loc4 followed by a four byte value. The value is
83 the difference of two addresses in the function. Since gcc does
84 not know this value, it always uses four bytes. We will know the
85 value at the end of assembly, so we can do better. */
87 static int eh_frame_code_alignment
PARAMS ((void));
89 /* Get the code alignment factor from the CIE. */
92 eh_frame_code_alignment ()
94 static int code_alignment
;
96 subsegT current_subseg
;
100 char augmentation
[10];
103 if (code_alignment
!= 0)
104 return code_alignment
;
106 /* We should find the CIE at the start of the .eh_frame section. */
108 current_seg
= now_seg
;
109 current_subseg
= now_subseg
;
110 subseg_new (".eh_frame", 0);
111 #if defined (BFD_ASSEMBLER) || defined (MANY_SEGMENTS)
112 f
= seg_info (now_seg
)->frchainP
->frch_root
;
114 f
= frchain_now
->frch_root
;
117 fix
= seg_info (now_seg
)->frchainP
->fix_root
;
119 fix
= *seg_fix_rootP
;
121 subseg_set (current_seg
, current_subseg
);
123 /* Look through the frags of the section to find the code alignment. */
125 /* First make sure that the CIE Identifier Tag is 0. */
128 while (f
!= NULL
&& offset
>= f
->fr_fix
)
134 || f
->fr_fix
- offset
< 4
135 || f
->fr_literal
[offset
] != 0
136 || f
->fr_literal
[offset
+ 1] != 0
137 || f
->fr_literal
[offset
+ 2] != 0
138 || f
->fr_literal
[offset
+ 3] != 0)
144 /* Next make sure the CIE version number is 1. */
147 while (f
!= NULL
&& offset
>= f
->fr_fix
)
153 || f
->fr_fix
- offset
< 1
154 || f
->fr_literal
[offset
] != 1)
160 /* Skip the augmentation (a null terminated string). */
166 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
)
200 augmentation
[iaug
] = '\0';
201 if (augmentation
[0] == '\0')
203 /* No augmentation. */
205 else if (strcmp (augmentation
, "eh") == 0)
207 /* We have to skip a pointer. Unfortunately, we don't know how
208 large it is. We find out by looking for a matching fixup. */
210 && (fix
->fx_frag
!= f
|| fix
->fx_where
!= offset
))
215 offset
+= fix
->fx_size
;
216 while (f
!= NULL
&& offset
>= f
->fr_fix
)
233 /* We're now at the code alignment factor, which is a ULEB128. If
234 it isn't a single byte, forget it. */
236 code_alignment
= f
->fr_literal
[offset
] & 0xff;
237 if ((code_alignment
& 0x80) != 0 || code_alignment
== 0)
243 return code_alignment
;
246 /* This function is called from emit_expr. It looks for cases which
249 Rather than try to parse all this information as we read it, we
250 look for a single byte DW_CFA_advance_loc4 followed by a 4 byte
251 difference. We turn that into a rs_cfa_advance frag, and handle
252 those frags at the end of the assembly. If the gcc output changes
253 somewhat, this optimization may stop working.
255 This function returns non-zero if it handled the expression and
256 emit_expr should not do anything, or zero otherwise. It can also
257 change *EXP and *PNBYTES. */
260 check_eh_frame (exp
, pnbytes
)
262 unsigned int *pnbytes
;
265 static symbolS
*size_end_sym
;
266 static int saw_advance_loc4
;
267 static fragS
*loc4_frag
;
271 && S_IS_DEFINED (size_end_sym
))
273 /* We have come to the end of the CIE or FDE. See below where
274 we set saw_size. We must check this first because we may now
275 be looking at the next size. */
277 saw_advance_loc4
= 0;
280 if (flag_traditional_format
)
282 /* Don't optimize. */
284 else if (strcmp (segment_name (now_seg
), ".eh_frame") != 0)
287 saw_advance_loc4
= 0;
292 /* This might be the size of the CIE or FDE. We want to know
293 the size so that we don't accidentally optimize across an FDE
294 boundary. We recognize the size in one of two forms: a
295 symbol which will later be defined as a difference, or a
296 subtraction of two symbols. Either way, we can tell when we
297 are at the end of the FDE because the symbol becomes defined
298 (in the case of a subtraction, the end symbol, from which the
299 start symbol is being subtracted). Other ways of describing
300 the size will not be optimized. */
301 if ((exp
->X_op
== O_symbol
|| exp
->X_op
== O_subtract
)
302 && ! S_IS_DEFINED (exp
->X_add_symbol
))
305 size_end_sym
= exp
->X_add_symbol
;
310 && exp
->X_op
== O_constant
311 && exp
->X_add_number
== DW_CFA_advance_loc4
)
313 /* This might be a DW_CFA_advance_loc4. Record the frag and the
314 position within the frag, so that we can change it later. */
315 saw_advance_loc4
= 1;
317 loc4_frag
= frag_now
;
318 loc4_fix
= frag_now_fix ();
320 else if (saw_advance_loc4
322 && exp
->X_op
== O_constant
)
326 /* This is a case which we can optimize. The two symbols being
327 subtracted were in the same frag and the expression was
328 reduced to a constant. We can do the optimization entirely
331 saw_advance_loc4
= 0;
333 ca
= eh_frame_code_alignment ();
336 /* Don't optimize. */
338 else if (exp
->X_add_number
% ca
== 0
339 && exp
->X_add_number
/ ca
< 0x40)
341 loc4_frag
->fr_literal
[loc4_fix
]
342 = DW_CFA_advance_loc
| (exp
->X_add_number
/ ca
);
343 /* No more bytes needed. */
346 else if (exp
->X_add_number
< 0x100)
348 loc4_frag
->fr_literal
[loc4_fix
] = DW_CFA_advance_loc1
;
351 else if (exp
->X_add_number
< 0x10000)
353 loc4_frag
->fr_literal
[loc4_fix
] = DW_CFA_advance_loc2
;
357 else if (saw_advance_loc4
359 && exp
->X_op
== O_subtract
)
362 /* This is a case we can optimize. The expression was not
363 reduced, so we can not finish the optimization until the end
364 of the assembly. We set up a variant frag which we handle
367 saw_advance_loc4
= 0;
369 frag_var (rs_cfa
, 4, 0, 0, make_expr_symbol (exp
),
370 loc4_fix
, (char *) loc4_frag
);
375 saw_advance_loc4
= 0;
380 /* The function estimates the size of a rs_cfa variant frag based on
381 the current values of the symbols. It is called before the
382 relaxation loop. We set fr_subtype to the expected length. */
385 eh_frame_estimate_size_before_relax (frag
)
392 ca
= eh_frame_code_alignment ();
393 diff
= resolve_symbol_value (frag
->fr_symbol
, 0);
397 else if (diff
% ca
== 0 && diff
/ ca
< 0x40)
399 else if (diff
< 0x100)
401 else if (diff
< 0x10000)
406 frag
->fr_subtype
= ret
;
411 /* This function relaxes a rs_cfa variant frag based on the current
412 values of the symbols. fr_subtype is the current length of the
413 frag. This returns the change in frag length. */
416 eh_frame_relax_frag (frag
)
419 int oldsize
, newsize
;
421 oldsize
= frag
->fr_subtype
;
422 newsize
= eh_frame_estimate_size_before_relax (frag
);
423 return newsize
- oldsize
;
426 /* This function converts a rs_cfa variant frag into a normal fill
427 frag. This is called after all relaxation has been done.
428 fr_subtype will be the desired length of the frag. */
431 eh_frame_convert_frag (frag
)
438 loc4_frag
= (fragS
*) frag
->fr_opcode
;
439 loc4_fix
= (int) frag
->fr_offset
;
441 diff
= resolve_symbol_value (frag
->fr_symbol
, 1);
443 if (frag
->fr_subtype
== 0)
447 ca
= eh_frame_code_alignment ();
448 assert (ca
> 0 && diff
% ca
== 0 && diff
/ ca
< 0x40);
449 loc4_frag
->fr_literal
[loc4_fix
] = DW_CFA_advance_loc
| (diff
/ ca
);
451 else if (frag
->fr_subtype
== 1)
453 assert (diff
< 0x100);
454 loc4_frag
->fr_literal
[loc4_fix
] = DW_CFA_advance_loc1
;
455 frag
->fr_literal
[frag
->fr_fix
] = diff
;
457 else if (frag
->fr_subtype
== 2)
459 assert (diff
< 0x10000);
460 loc4_frag
->fr_literal
[loc4_fix
] = DW_CFA_advance_loc2
;
461 md_number_to_chars (frag
->fr_literal
+ frag
->fr_fix
, diff
, 2);
464 md_number_to_chars (frag
->fr_literal
+ frag
->fr_fix
, diff
, 4);
466 frag
->fr_fix
+= frag
->fr_subtype
;
467 frag
->fr_type
= rs_fill
;
This page took 0.038377 seconds and 4 git commands to generate.