Deleted Added
sdiff udiff text old ( 77298 ) new ( 78828 )
full compact
1/* ehopt.c--optimize gcc exception frame information.
2 Copyright (C) 1998, 2000 Free Software Foundation, Inc.
2 Copyright 1998, 2000, 2001 Free Software Foundation, Inc.
3 Written by Ian Lance Taylor <ian@cygnus.com>.
4
5This file is part of GAS, the GNU Assembler.
6
7GAS is free software; you can redistribute it and/or modify
8it under the terms of the GNU General Public License as published by
9the Free Software Foundation; either version 2, or (at your option)
10any later version.
11
12GAS is distributed in the hope that it will be useful,
13but WITHOUT ANY WARRANTY; without even the implied warranty of
14MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15GNU General Public License for more details.
16
17You should have received a copy of the GNU General Public License
18along with GAS; see the file COPYING. If not, write to the Free
19Software Foundation, 59 Temple Place - Suite 330, Boston, MA
2002111-1307, USA. */
21
22#include "as.h"
23#include "subsegs.h"
24
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. */
28
29#include "elf/dwarf2.h"
30
31/* Try to optimize gcc 2.8 exception frame information.
32
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:
36
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
84
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. */
90
91static int eh_frame_code_alignment PARAMS ((int));
91struct cie_info
92{
93 unsigned code_alignment;
94 int z_augmentation;
95};
96
93/* Get the code alignment factor from the CIE. */
97static int get_cie_info PARAMS ((struct cie_info *));
98
99/* Extract information from the CIE. */
100
101static int
96eh_frame_code_alignment (in_seg)
97 int in_seg;
102get_cie_info (info)
103 struct cie_info *info;
104{
99 /* ??? Assume .eh_frame and .debug_frame have the same alignment. */
100 static int code_alignment;
101
105 fragS *f;
106 fixS *fix;
107 int offset;
108 char CIE_id;
109 char augmentation[10];
110 int iaug;
111 int code_alignment = 0;
112
109 if (code_alignment != 0)
110 return code_alignment;
111
112 /* Can't find the alignment if we've changed sections. */
113 if (! in_seg)
114 return -1;
115
113 /* We should find the CIE at the start of the section. */
114
115#if defined (BFD_ASSEMBLER) || defined (MANY_SEGMENTS)
116 f = seg_info (now_seg)->frchainP->frch_root;
117#else
118 f = frchain_now->frch_root;
119#endif
120#ifdef BFD_ASSEMBLER
121 fix = seg_info (now_seg)->frchainP->fix_root;
122#else
123 fix = *seg_fix_rootP;
124#endif
125
126 /* Look through the frags of the section to find the code alignment. */
127
128 /* First make sure that the CIE Identifier Tag is 0/-1. */
129
130 if (strcmp (segment_name (now_seg), ".debug_frame") == 0)
131 CIE_id = (char)0xff;
132 else
133 CIE_id = 0;
134
135 offset = 4;
136 while (f != NULL && offset >= f->fr_fix)
137 {
138 offset -= f->fr_fix;
139 f = f->fr_next;
140 }
141 if (f == NULL
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)
150 {
151 code_alignment = -1;
152 return -1;
153 }
147 return 0;
148
149 /* Next make sure the CIE version number is 1. */
150
151 offset += 4;
152 while (f != NULL && offset >= f->fr_fix)
153 {
154 offset -= f->fr_fix;
155 f = f->fr_next;
156 }
157 if (f == NULL
158 || f->fr_fix - offset < 1
159 || f->fr_literal[offset] != 1)
166 {
167 code_alignment = -1;
168 return -1;
169 }
160 return 0;
161
162 /* Skip the augmentation (a null terminated string). */
163
164 iaug = 0;
165 ++offset;
166 while (1)
167 {
168 while (f != NULL && offset >= f->fr_fix)
169 {
170 offset -= f->fr_fix;
171 f = f->fr_next;
172 }
173 if (f == NULL)
183 {
184 code_alignment = -1;
185 return -1;
186 }
174 return 0;
175
176 while (offset < f->fr_fix && f->fr_literal[offset] != '\0')
177 {
178 if ((size_t) iaug < (sizeof augmentation) - 1)
179 {
180 augmentation[iaug] = f->fr_literal[offset];
181 ++iaug;
182 }
183 ++offset;
184 }
185 if (offset < f->fr_fix)
186 break;
187 }
188 ++offset;
189 while (f != NULL && offset >= f->fr_fix)
190 {
191 offset -= f->fr_fix;
192 f = f->fr_next;
193 }
194 if (f == NULL)
206 {
207 code_alignment = -1;
208 return -1;
209 }
195 return 0;
196
197 augmentation[iaug] = '\0';
198 if (augmentation[0] == '\0')
199 {
200 /* No augmentation. */
201 }
202 else if (strcmp (augmentation, "eh") == 0)
203 {
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. */
206 while (fix != NULL
207 && (fix->fx_frag != f || fix->fx_where != offset))
208 fix = fix->fx_next;
209 if (fix == NULL)
210 offset += 4;
211 else
212 offset += fix->fx_size;
213 while (f != NULL && offset >= f->fr_fix)
214 {
215 offset -= f->fr_fix;
216 f = f->fr_next;
217 }
218 if (f == NULL)
233 {
234 code_alignment = -1;
235 return -1;
236 }
219 return 0;
220 }
238 else
239 {
240 code_alignment = -1;
241 return -1;
242 }
221 else if (augmentation[0] != 'z')
222 return 0;
223
224 /* We're now at the code alignment factor, which is a ULEB128. If
225 it isn't a single byte, forget it. */
226
227 code_alignment = f->fr_literal[offset] & 0xff;
248 if ((code_alignment & 0x80) != 0 || code_alignment == 0)
249 {
250 code_alignment = -1;
251 return -1;
252 }
228 if ((code_alignment & 0x80) != 0)
229 code_alignment = 0;
230
254 return code_alignment;
231 info->code_alignment = code_alignment;
232 info->z_augmentation = (augmentation[0] == 'z');
233
234 return 1;
235}
236
237/* This function is called from emit_expr. It looks for cases which
238 we can optimize.
239
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.
245
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. */
249
250int
251check_eh_frame (exp, pnbytes)
252 expressionS *exp;
253 unsigned int *pnbytes;
254{
255 struct frame_data
256 {
257 enum frame_state
258 {
259 state_idle,
260 state_saw_size,
261 state_saw_cie_offset,
262 state_saw_pc_begin,
263 state_seeing_aug_size,
264 state_skipping_aug,
265 state_wait_loc4,
266 state_saw_loc4,
267 state_error,
268 } state;
269
270 int cie_info_ok;
271 struct cie_info cie_info;
272
273 symbolS *size_end_sym;
274 fragS *loc4_frag;
279 int saw_size;
280 int saw_advance_loc4;
275 int loc4_fix;
276
277 int aug_size;
278 int aug_shift;
279 };
280
281 static struct frame_data eh_frame_data;
282 static struct frame_data debug_frame_data;
283 struct frame_data *d;
284
285 /* Don't optimize. */
286 if (flag_traditional_format)
287 return 0;
288
289 /* Select the proper section data. */
290 if (strcmp (segment_name (now_seg), ".eh_frame") == 0)
291 d = &eh_frame_data;
292 else if (strcmp (segment_name (now_seg), ".debug_frame") == 0)
293 d = &debug_frame_data;
294 else
295 return 0;
296
300 if (d->saw_size && S_IS_DEFINED (d->size_end_sym))
297 if (d->state >= state_saw_size && S_IS_DEFINED (d->size_end_sym))
298 {
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. */
305 d->saw_size = 0;
306 d->saw_advance_loc4 = 0;
302 d->state = state_idle;
303 }
304
309 if (! d->saw_size
310 && *pnbytes == 4)
305 switch (d->state)
306 {
312 /* This might be the size of the CIE or FDE. We want to know
313 the size so that we don't accidentally optimize across an FDE
314 boundary. We recognize the size in one of two forms: a
315 symbol which will later be defined as a difference, or a
316 subtraction of two symbols. Either way, we can tell when we
317 are at the end of the FDE because the symbol becomes defined
318 (in the case of a subtraction, the end symbol, from which the
319 start symbol is being subtracted). Other ways of describing
320 the size will not be optimized. */
321 if ((exp->X_op == O_symbol || exp->X_op == O_subtract)
322 && ! S_IS_DEFINED (exp->X_add_symbol))
307 case state_idle:
308 if (*pnbytes == 4)
309 {
324 d->saw_size = 1;
325 d->size_end_sym = exp->X_add_symbol;
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))
321 {
322 d->state = state_saw_size;
323 d->size_end_sym = exp->X_add_symbol;
324 }
325 }
327 }
328 else if (d->saw_size
329 && *pnbytes == 1
330 && exp->X_op == O_constant
331 && exp->X_add_number == DW_CFA_advance_loc4)
332 {
333 /* This might be a DW_CFA_advance_loc4. Record the frag and the
334 position within the frag, so that we can change it later. */
335 d->saw_advance_loc4 = 1;
336 frag_grow (1);
337 d->loc4_frag = frag_now;
338 d->loc4_fix = frag_now_fix ();
339 }
340 else if (d->saw_advance_loc4
341 && *pnbytes == 4
342 && exp->X_op == O_constant)
343 {
344 int ca;
326 break;
327
346 /* This is a case which we can optimize. The two symbols being
347 subtracted were in the same frag and the expression was
348 reduced to a constant. We can do the optimization entirely
349 in this function. */
328 case state_saw_size:
329 case state_saw_cie_offset:
330 /* Assume whatever form it appears in, it appears atomically. */
331 d->state += 1;
332 break;
333
351 d->saw_advance_loc4 = 0;
334 case state_saw_pc_begin:
335 /* Decide whether we should see an augmentation. */
336 if (! d->cie_info_ok
337 && ! (d->cie_info_ok = get_cie_info (&d->cie_info)))
338 d->state = state_error;
339 else if (d->cie_info.z_augmentation)
340 {
341 d->state = state_seeing_aug_size;
342 d->aug_size = 0;
343 d->aug_shift = 0;
344 }
345 else
346 d->state = state_wait_loc4;
347 break;
348
353 ca = eh_frame_code_alignment (1);
354 if (ca < 0)
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)
352 {
356 /* Don't optimize. */
353 d->aug_size = exp->X_add_number;
354 d->state = state_skipping_aug;
355 }
358 else if (exp->X_add_number % ca == 0
359 && exp->X_add_number / ca < 0x40)
356 else if (*pnbytes == 1 && exp->X_op == O_constant)
357 {
361 d->loc4_frag->fr_literal[d->loc4_fix]
362 = DW_CFA_advance_loc | (exp->X_add_number / ca);
363 /* No more bytes needed. */
364 return 1;
358 unsigned char byte = exp->X_add_number;
359 d->aug_size |= (byte & 0x7f) << d->aug_shift;
360 d->aug_shift += 7;
361 if ((byte & 0x80) == 0)
362 d->state = state_skipping_aug;
363 }
366 else if (exp->X_add_number < 0x100)
364 else
365 d->state = state_error;
366 break;
367
368 case state_skipping_aug:
369 if ((int)*pnbytes < 0)
370 d->state = state_error;
371 else
372 {
368 d->loc4_frag->fr_literal[d->loc4_fix] = DW_CFA_advance_loc1;
369 *pnbytes = 1;
373 int left = (d->aug_size -= *pnbytes);
374 if (left == 0)
375 d->state = state_wait_loc4;
376 else if (left < 0)
377 d->state = state_error;
378 }
371 else if (exp->X_add_number < 0x10000)
379 break;
380
381 case state_wait_loc4:
382 if (*pnbytes == 1
383 && exp->X_op == O_constant
384 && exp->X_add_number == DW_CFA_advance_loc4)
385 {
373 d->loc4_frag->fr_literal[d->loc4_fix] = DW_CFA_advance_loc2;
374 *pnbytes = 2;
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. */
388 frag_grow (1);
389 d->state = state_saw_loc4;
390 d->loc4_frag = frag_now;
391 d->loc4_fix = frag_now_fix ();
392 }
376 }
377 else if (d->saw_advance_loc4
378 && *pnbytes == 4
379 && exp->X_op == O_subtract)
380 {
381 /* This is a case we can optimize. The expression was not
382 reduced, so we can not finish the optimization until the end
383 of the assembly. We set up a variant frag which we handle
384 later. */
393 break;
394
386 d->saw_advance_loc4 = 0;
395 case state_saw_loc4:
396 d->state = state_wait_loc4;
397 if (*pnbytes != 4)
398 break;
399 if (exp->X_op == O_constant)
400 {
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
404 in this function. */
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)
408 {
409 d->loc4_frag->fr_literal[d->loc4_fix]
410 = DW_CFA_advance_loc
411 | (exp->X_add_number / d->cie_info.code_alignment);
412 /* No more bytes needed. */
413 return 1;
414 }
415 else if (exp->X_add_number < 0x100)
416 {
417 d->loc4_frag->fr_literal[d->loc4_fix] = DW_CFA_advance_loc1;
418 *pnbytes = 1;
419 }
420 else if (exp->X_add_number < 0x10000)
421 {
422 d->loc4_frag->fr_literal[d->loc4_fix] = DW_CFA_advance_loc2;
423 *pnbytes = 2;
424 }
425 }
426 else if (exp->X_op == O_subtract)
427 {
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
431 later. */
432 int fr_subtype;
433
388 frag_var (rs_cfa, 4, 0, 0, make_expr_symbol (exp),
389 d->loc4_fix, (char *) d->loc4_frag);
434 if (d->cie_info.code_alignment > 0)
435 fr_subtype = d->cie_info.code_alignment << 3;
436 else
437 fr_subtype = 0;
438
391 return 1;
439 frag_var (rs_cfa, 4, 0, fr_subtype, make_expr_symbol (exp),
440 d->loc4_fix, (char *) d->loc4_frag);
441 return 1;
442 }
443 break;
444
445 case state_error:
446 /* Just skipping everything. */
447 break;
448 }
393 else
394 d->saw_advance_loc4 = 0;
449
450 return 0;
451}
452
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
401 relaxation loop. We set fr_subtype to the expected length. */
455 relaxation loop. We set fr_subtype{0:2} to the expected length. */
456
457int
458eh_frame_estimate_size_before_relax (frag)
459 fragS *frag;
460{
407 int ca;
461 offsetT diff;
462 int ca = frag->fr_subtype >> 3;
463 int ret;
464
411 ca = eh_frame_code_alignment (0);
465 diff = resolve_symbol_value (frag->fr_symbol, 0);
466
414 if (ca < 0)
415 ret = 4;
416 else if (diff % ca == 0 && diff / ca < 0x40)
467 if (ca > 0 && diff % ca == 0 && diff / ca < 0x40)
468 ret = 0;
469 else if (diff < 0x100)
470 ret = 1;
471 else if (diff < 0x10000)
472 ret = 2;
473 else
474 ret = 4;
475
425 frag->fr_subtype = ret;
476 frag->fr_subtype = (frag->fr_subtype & ~7) | ret;
477
478 return ret;
479}
480
481/* This function relaxes a rs_cfa variant frag based on the current
431 values of the symbols. fr_subtype is the current length of the
432 frag. This returns the change in frag length. */
482 values of the symbols. fr_subtype{0:2} is the current length of
483 the frag. This returns the change in frag length. */
484
485int
486eh_frame_relax_frag (frag)
487 fragS *frag;
488{
489 int oldsize, newsize;
490
440 oldsize = frag->fr_subtype;
491 oldsize = frag->fr_subtype & 7;
492 newsize = eh_frame_estimate_size_before_relax (frag);
493 return newsize - oldsize;
494}
495
496/* This function converts a rs_cfa variant frag into a normal fill
497 frag. This is called after all relaxation has been done.
447 fr_subtype will be the desired length of the frag. */
498 fr_subtype{0:2} will be the desired length of the frag. */
499
500void
501eh_frame_convert_frag (frag)
502 fragS *frag;
503{
504 offsetT diff;
505 fragS *loc4_frag;
506 int loc4_fix;
507
508 loc4_frag = (fragS *) frag->fr_opcode;
509 loc4_fix = (int) frag->fr_offset;
510
511 diff = resolve_symbol_value (frag->fr_symbol, 1);
512
462 if (frag->fr_subtype == 0)
513 switch (frag->fr_subtype & 7)
514 {
464 int ca;
515 case 0:
516 {
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);
520 }
521 break;
522
466 ca = eh_frame_code_alignment (0);
467 assert (ca > 0 && diff % ca == 0 && diff / ca < 0x40);
468 loc4_frag->fr_literal[loc4_fix] = DW_CFA_advance_loc | (diff / ca);
469 }
470 else if (frag->fr_subtype == 1)
471 {
523 case 1:
524 assert (diff < 0x100);
525 loc4_frag->fr_literal[loc4_fix] = DW_CFA_advance_loc1;
526 frag->fr_literal[frag->fr_fix] = diff;
475 }
476 else if (frag->fr_subtype == 2)
477 {
527 break;
528
529 case 2:
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);
533 break;
534
535 default:
536 md_number_to_chars (frag->fr_literal + frag->fr_fix, diff, 4);
537 break;
538 }
482 else
483 md_number_to_chars (frag->fr_literal + frag->fr_fix, diff, 4);
539
485 frag->fr_fix += frag->fr_subtype;
540 frag->fr_fix += frag->fr_subtype & 7;
541 frag->fr_type = rs_fill;
542 frag->fr_subtype = 0;
543 frag->fr_offset = 0;
544}