1/* ehopt.c--optimize gcc exception frame information.
2 Copyright (C) 1998, 2000 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.

--- 72 unchanged lines hidden (view full) ---

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));
92
93/* Get the code alignment factor from the CIE. */
94
95static int
96eh_frame_code_alignment (in_seg)
97 int in_seg;
98{
99 /* ??? Assume .eh_frame and .debug_frame have the same alignment. */
100 static int code_alignment;
101
102 fragS *f;
103 fixS *fix;
104 int offset;
105 char CIE_id;
106 char augmentation[10];
107 int iaug;
108
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
116 /* We should find the CIE at the start of the section. */
117
118#if defined (BFD_ASSEMBLER) || defined (MANY_SEGMENTS)
119 f = seg_info (now_seg)->frchainP->frch_root;
120#else
121 f = frchain_now->frch_root;
122#endif
123#ifdef BFD_ASSEMBLER

--- 18 unchanged lines hidden (view full) ---

142 f = f->fr_next;
143 }
144 if (f == NULL
145 || f->fr_fix - offset < 4
146 || f->fr_literal[offset] != CIE_id
147 || f->fr_literal[offset + 1] != CIE_id
148 || f->fr_literal[offset + 2] != CIE_id
149 || f->fr_literal[offset + 3] != CIE_id)
150 {
151 code_alignment = -1;
152 return -1;
153 }
154
155 /* Next make sure the CIE version number is 1. */
156
157 offset += 4;
158 while (f != NULL && offset >= f->fr_fix)
159 {
160 offset -= f->fr_fix;
161 f = f->fr_next;
162 }
163 if (f == NULL
164 || f->fr_fix - offset < 1
165 || f->fr_literal[offset] != 1)
166 {
167 code_alignment = -1;
168 return -1;
169 }
170
171 /* Skip the augmentation (a null terminated string). */
172
173 iaug = 0;
174 ++offset;
175 while (1)
176 {
177 while (f != NULL && offset >= f->fr_fix)
178 {
179 offset -= f->fr_fix;
180 f = f->fr_next;
181 }
182 if (f == NULL)
183 {
184 code_alignment = -1;
185 return -1;
186 }
187 while (offset < f->fr_fix && f->fr_literal[offset] != '\0')
188 {
189 if ((size_t) iaug < (sizeof augmentation) - 1)
190 {
191 augmentation[iaug] = f->fr_literal[offset];
192 ++iaug;
193 }
194 ++offset;
195 }
196 if (offset < f->fr_fix)
197 break;
198 }
199 ++offset;
200 while (f != NULL && offset >= f->fr_fix)
201 {
202 offset -= f->fr_fix;
203 f = f->fr_next;
204 }
205 if (f == NULL)
206 {
207 code_alignment = -1;
208 return -1;
209 }
210
211 augmentation[iaug] = '\0';
212 if (augmentation[0] == '\0')
213 {
214 /* No augmentation. */
215 }
216 else if (strcmp (augmentation, "eh") == 0)
217 {

--- 7 unchanged lines hidden (view full) ---

225 else
226 offset += fix->fx_size;
227 while (f != NULL && offset >= f->fr_fix)
228 {
229 offset -= f->fr_fix;
230 f = f->fr_next;
231 }
232 if (f == NULL)
233 {
234 code_alignment = -1;
235 return -1;
236 }
237 }
238 else
239 {
240 code_alignment = -1;
241 return -1;
242 }
243
244 /* We're now at the code alignment factor, which is a ULEB128. If
245 it isn't a single byte, forget it. */
246
247 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 }
253
254 return code_alignment;
255}
256
257/* This function is called from emit_expr. It looks for cases which
258 we can optimize.
259
260 Rather than try to parse all this information as we read it, we
261 look for a single byte DW_CFA_advance_loc4 followed by a 4 byte
262 difference. We turn that into a rs_cfa_advance frag, and handle

--- 6 unchanged lines hidden (view full) ---

269
270int
271check_eh_frame (exp, pnbytes)
272 expressionS *exp;
273 unsigned int *pnbytes;
274{
275 struct frame_data
276 {
277 symbolS *size_end_sym;
278 fragS *loc4_frag;
279 int saw_size;
280 int saw_advance_loc4;
281 int loc4_fix;
282 };
283
284 static struct frame_data eh_frame_data;
285 static struct frame_data debug_frame_data;
286 struct frame_data *d;
287
288 /* Don't optimize. */
289 if (flag_traditional_format)
290 return 0;
291
292 /* Select the proper section data. */
293 if (strcmp (segment_name (now_seg), ".eh_frame") == 0)
294 d = &eh_frame_data;
295 else if (strcmp (segment_name (now_seg), ".debug_frame") == 0)
296 d = &debug_frame_data;
297 else
298 return 0;
299
300 if (d->saw_size && S_IS_DEFINED (d->size_end_sym))
301 {
302 /* We have come to the end of the CIE or FDE. See below where
303 we set saw_size. We must check this first because we may now
304 be looking at the next size. */
305 d->saw_size = 0;
306 d->saw_advance_loc4 = 0;
307 }
308
309 if (! d->saw_size
310 && *pnbytes == 4)
311 {
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))
323 {
324 d->saw_size = 1;
325 d->size_end_sym = exp->X_add_symbol;
326 }
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;
345
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. */
350
351 d->saw_advance_loc4 = 0;
352
353 ca = eh_frame_code_alignment (1);
354 if (ca < 0)
355 {
356 /* Don't optimize. */
357 }
358 else if (exp->X_add_number % ca == 0
359 && exp->X_add_number / ca < 0x40)
360 {
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;
365 }
366 else if (exp->X_add_number < 0x100)
367 {
368 d->loc4_frag->fr_literal[d->loc4_fix] = DW_CFA_advance_loc1;
369 *pnbytes = 1;
370 }
371 else if (exp->X_add_number < 0x10000)
372 {
373 d->loc4_frag->fr_literal[d->loc4_fix] = DW_CFA_advance_loc2;
374 *pnbytes = 2;
375 }
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. */
385
386 d->saw_advance_loc4 = 0;
387
388 frag_var (rs_cfa, 4, 0, 0, make_expr_symbol (exp),
389 d->loc4_fix, (char *) d->loc4_frag);
390
391 return 1;
392 }
393 else
394 d->saw_advance_loc4 = 0;
395
396 return 0;
397}
398
399/* The function estimates the size of a rs_cfa variant frag based on
400 the current values of the symbols. It is called before the
401 relaxation loop. We set fr_subtype to the expected length. */
402
403int
404eh_frame_estimate_size_before_relax (frag)
405 fragS *frag;
406{
407 int ca;
408 offsetT diff;
409 int ret;
410
411 ca = eh_frame_code_alignment (0);
412 diff = resolve_symbol_value (frag->fr_symbol, 0);
413
414 if (ca < 0)
415 ret = 4;
416 else if (diff % ca == 0 && diff / ca < 0x40)
417 ret = 0;
418 else if (diff < 0x100)
419 ret = 1;
420 else if (diff < 0x10000)
421 ret = 2;
422 else
423 ret = 4;
424
425 frag->fr_subtype = ret;
426
427 return ret;
428}
429
430/* 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. */
433
434int
435eh_frame_relax_frag (frag)
436 fragS *frag;
437{
438 int oldsize, newsize;
439
440 oldsize = frag->fr_subtype;
441 newsize = eh_frame_estimate_size_before_relax (frag);
442 return newsize - oldsize;
443}
444
445/* This function converts a rs_cfa variant frag into a normal fill
446 frag. This is called after all relaxation has been done.
447 fr_subtype will be the desired length of the frag. */
448
449void
450eh_frame_convert_frag (frag)
451 fragS *frag;
452{
453 offsetT diff;
454 fragS *loc4_frag;
455 int loc4_fix;
456
457 loc4_frag = (fragS *) frag->fr_opcode;
458 loc4_fix = (int) frag->fr_offset;
459
460 diff = resolve_symbol_value (frag->fr_symbol, 1);
461
462 if (frag->fr_subtype == 0)
463 {
464 int ca;
465
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 {
472 assert (diff < 0x100);
473 loc4_frag->fr_literal[loc4_fix] = DW_CFA_advance_loc1;
474 frag->fr_literal[frag->fr_fix] = diff;
475 }
476 else if (frag->fr_subtype == 2)
477 {
478 assert (diff < 0x10000);
479 loc4_frag->fr_literal[loc4_fix] = DW_CFA_advance_loc2;
480 md_number_to_chars (frag->fr_literal + frag->fr_fix, diff, 2);
481 }
482 else
483 md_number_to_chars (frag->fr_literal + frag->fr_fix, diff, 4);
484
485 frag->fr_fix += frag->fr_subtype;
486 frag->fr_type = rs_fill;
487 frag->fr_offset = 0;
488}