gas/ehopt.c

   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>.
   5
   6    This file is part of GAS, the GNU Assembler.
   7
   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)
  11    any later version.
  12
  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.
  17
  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
  21    02110-1301, USA.  */
  22
  23 #include "as.h"
  24 #include "subsegs.h"
  25 #include "struc-symbol.h"
  26
  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.  */
  30
  31 #include "elf/dwarf2.h"
  32
  33 /* Try to optimize gcc 2.8 exception frame information.
  34
  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:
  38
  39 __FRAME_BEGIN__:
  40         .4byte  .LLCIE1 / Length of Common Information Entry
  41 .LSCIE1:
  42 #if .eh_frame
  43         .4byte  0x0     / CIE Identifier Tag
  44 #elif .debug_frame
  45         .4byte  0xffffffff / CIE Identifier Tag
  46 #endif
  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
  57         .align 4
  58 .LECIE1:
  59         .set    .LLCIE1,.LECIE1-.LSCIE1 / CIE Length Symbol
  60         .4byte  .LLFDE1 / FDE Length
  61 .LSFDE1:
  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
  66         .4byte  .LCFI0-.LFB1
  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
  72         .4byte  .LCFI1-.LCFI0
  73         .byte   0xd     / DW_CFA_def_cfa_register
  74         .byte   0x5     / ULEB128 0x5
  75         .byte   0x4     / DW_CFA_advance_loc4
  76         .4byte  .LCFI2-.LCFI1
  77         .byte   0x2e    / DW_CFA_GNU_args_size
  78         .byte   0x4     / ULEB128 0x4
  79         .byte   0x4     / DW_CFA_advance_loc4
  80         .4byte  .LCFI3-.LCFI2
  81         .byte   0x2e    / DW_CFA_GNU_args_size
  82         .byte   0x0     / ULEB128 0x0
  83         .align 4
  84 .LEFDE1:
  85         .set    .LLFDE1,.LEFDE1-.LSFDE1 / FDE Length Symbol
  86
  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.  */
  92
  93 struct cie_info
  94 {
  95   unsigned code_alignment;
  96   int z_augmentation;
  97 };
  98
  99 static int get_cie_info (struct cie_info *);
 100
 101 /* Extract information from the CIE.  */
 102
 103 static int
 104 get_cie_info (struct cie_info *info)
 105 {
 106   fragS *f;
 107   fixS *fix;
 108   int offset;
 109   char CIE_id;
 110   char augmentation[10];
 111   int iaug;
 112   int code_alignment = 0;
 113
 114   /* We should find the CIE at the start of the section.  */
 115
 116   f = seg_info (now_seg)->frchainP->frch_root;
 117   fix = seg_info (now_seg)->frchainP->fix_root;
 118
 119   /* Look through the frags of the section to find the code alignment.  */
 120
 121   /* First make sure that the CIE Identifier Tag is 0/-1.  */
 122
 123   if (strcmp (segment_name (now_seg), ".debug_frame") == 0)
 124     CIE_id = (char)0xff;
 125   else
 126     CIE_id = 0;
 127
 128   offset = 4;
 129   while (f != NULL && offset >= f->fr_fix)
 130     {
 131       offset -= f->fr_fix;
 132       f = f->fr_next;
 133     }
 134   if (f == NULL
 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)
 140     return 0;
 141
 142   /* Next make sure the CIE version number is 1.  */
 143
 144   offset += 4;
 145   while (f != NULL && offset >= f->fr_fix)
 146     {
 147       offset -= f->fr_fix;
 148       f = f->fr_next;
 149     }
 150   if (f == NULL
 151       || f->fr_fix - offset < 1
 152       || f->fr_literal[offset] != 1)
 153     return 0;
 154
 155   /* Skip the augmentation (a null terminated string).  */
 156
 157   iaug = 0;
 158   ++offset;
 159   while (1)
 160     {
 161       while (f != NULL && offset >= f->fr_fix)
 162         {
 163           offset -= f->fr_fix;
 164           f = f->fr_next;
 165         }
 166       if (f == NULL)
 167         return 0;
 168
 169       while (offset < f->fr_fix && f->fr_literal[offset] != '\0')
 170         {
 171           if ((size_t) iaug < (sizeof augmentation) - 1)
 172             {
 173               augmentation[iaug] = f->fr_literal[offset];
 174               ++iaug;
 175             }
 176           ++offset;
 177         }
 178       if (offset < f->fr_fix)
 179         break;
 180     }
 181   ++offset;
 182   while (f != NULL && offset >= f->fr_fix)
 183     {
 184       offset -= f->fr_fix;
 185       f = f->fr_next;
 186     }
 187   if (f == NULL)
 188     return 0;
 189
 190   augmentation[iaug] = '\0';
 191   if (augmentation[0] == '\0')
 192     {
 193       /* No augmentation.  */
 194     }
 195   else if (strcmp (augmentation, "eh") == 0)
 196     {
 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.  */
 199       while (fix != NULL
 200              && (fix->fx_frag != f || fix->fx_where != offset))
 201         fix = fix->fx_next;
 202       if (fix == NULL)
 203         offset += 4;
 204       else
 205         offset += fix->fx_size;
 206       while (f != NULL && offset >= f->fr_fix)
 207         {
 208           offset -= f->fr_fix;
 209           f = f->fr_next;
 210         }
 211       if (f == NULL)
 212         return 0;
 213     }
 214   else if (augmentation[0] != 'z')
 215     return 0;
 216
 217   /* We're now at the code alignment factor, which is a ULEB128.  If
 218      it isn't a single byte, forget it.  */
 219
 220   code_alignment = f->fr_literal[offset] & 0xff;
 221   if ((code_alignment & 0x80) != 0)
 222     code_alignment = 0;
 223
 224   info->code_alignment = code_alignment;
 225   info->z_augmentation = (augmentation[0] == 'z');
 226
 227   return 1;
 228 }
 229
 230 /* This function is called from emit_expr.  It looks for cases which
 231    we can optimize.
 232
 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.
 238
 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.  */
 242
 243 int
 244 check_eh_frame (expressionS *exp, unsigned int *pnbytes)
 245 {
 246   struct frame_data
 247   {
 248     enum frame_state
 249     {
 250       state_idle,
 251       state_saw_size,
 252       state_saw_cie_offset,
 253       state_saw_pc_begin,
 254       state_seeing_aug_size,
 255       state_skipping_aug,
 256       state_wait_loc4,
 257       state_saw_loc4,
 258       state_error,
 259     } state;
 260
 261     int cie_info_ok;
 262     struct cie_info cie_info;
 263
 264     symbolS *size_end_sym;
 265     fragS *loc4_frag;
 266     int loc4_fix;
 267
 268     int aug_size;
 269     int aug_shift;
 270   };
 271
 272   static struct frame_data eh_frame_data;
 273   static struct frame_data debug_frame_data;
 274   struct frame_data *d;
 275
 276   /* Don't optimize.  */
 277   if (flag_traditional_format)
 278     return 0;
 279
 280 #ifdef md_allow_eh_opt
 281   if (! md_allow_eh_opt)
 282     return 0;
 283 #endif
 284
 285   /* Select the proper section data.  */
 286   if (strcmp (segment_name (now_seg), ".eh_frame") == 0)
 287     d = &eh_frame_data;
 288   else if (strcmp (segment_name (now_seg), ".debug_frame") == 0)
 289     d = &debug_frame_data;
 290   else
 291     return 0;
 292
 293   if (d->state >= state_saw_size && S_IS_DEFINED (d->size_end_sym))
 294     {
 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;
 299     }
 300
 301   switch (d->state)
 302     {
 303     case state_idle:
 304       if (*pnbytes == 4)
 305         {
 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))
 317             {
 318               d->state = state_saw_size;
 319               d->size_end_sym = exp->X_add_symbol;
 320             }
 321         }
 322       break;
 323
 324     case state_saw_size:
 325     case state_saw_cie_offset:
 326       /* Assume whatever form it appears in, it appears atomically.  */
 327       d->state += 1;
 328       break;
 329
 330     case state_saw_pc_begin:
 331       /* Decide whether we should see an augmentation.  */
 332       if (! d->cie_info_ok
 333           && ! (d->cie_info_ok = get_cie_info (&d->cie_info)))
 334         d->state = state_error;
 335       else if (d->cie_info.z_augmentation)
 336         {
 337           d->state = state_seeing_aug_size;
 338           d->aug_size = 0;
 339           d->aug_shift = 0;
 340         }
 341       else
 342         d->state = state_wait_loc4;
 343       break;
 344
 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)
 348         {
 349           d->aug_size = exp->X_add_number;
 350           d->state = state_skipping_aug;
 351         }
 352       else if (*pnbytes == 1 && exp->X_op == O_constant)
 353         {
 354           unsigned char byte = exp->X_add_number;
 355           d->aug_size |= (byte & 0x7f) << d->aug_shift;
 356           d->aug_shift += 7;
 357           if ((byte & 0x80) == 0)
 358             d->state = state_skipping_aug;
 359         }
 360       else
 361         d->state = state_error;
 362       if (d->state == state_skipping_aug && d->aug_size == 0)
 363         d->state = state_wait_loc4;
 364       break;
 365
 366     case state_skipping_aug:
 367       if ((int)*pnbytes < 0)
 368         d->state = state_error;
 369       else
 370         {
 371           int left = (d->aug_size -= *pnbytes);
 372           if (left == 0)
 373             d->state = state_wait_loc4;
 374           else if (left < 0)
 375             d->state = state_error;
 376         }
 377       break;
 378
 379     case state_wait_loc4:
 380       if (*pnbytes == 1
 381           && exp->X_op == O_constant
 382           && exp->X_add_number == DW_CFA_advance_loc4)
 383         {
 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.  */
 386           frag_grow (1);
 387           d->state = state_saw_loc4;
 388           d->loc4_frag = frag_now;
 389           d->loc4_fix = frag_now_fix ();
 390         }
 391       break;
 392
 393     case state_saw_loc4:
 394       d->state = state_wait_loc4;
 395       if (*pnbytes != 4)
 396         break;
 397       if (exp->X_op == O_constant)
 398         {
 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
 402              in this function.  */
 403           if (exp->X_add_number < 0x40)
 404             {
 405               d->loc4_frag->fr_literal[d->loc4_fix]
 406                 = DW_CFA_advance_loc | exp->X_add_number;
 407               /* No more bytes needed.  */
 408               return 1;
 409             }
 410           else if (exp->X_add_number < 0x100)
 411             {
 412               d->loc4_frag->fr_literal[d->loc4_fix] = DW_CFA_advance_loc1;
 413               *pnbytes = 1;
 414             }
 415           else if (exp->X_add_number < 0x10000)
 416             {
 417               d->loc4_frag->fr_literal[d->loc4_fix] = DW_CFA_advance_loc2;
 418               *pnbytes = 2;
 419             }
 420         }
 421       else if (exp->X_op == O_subtract && d->cie_info.code_alignment == 1)
 422         {
 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
 426              later.  */
 427           frag_var (rs_cfa, 4, 0, 1 << 3, make_expr_symbol (exp),
 428                     d->loc4_fix, (char *) d->loc4_frag);
 429           return 1;
 430         }
 431       else if ((exp->X_op == O_divide
 432                 || exp->X_op == O_right_shift)
 433                && d->cie_info.code_alignment > 1)
 434         {
 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))
 443             {
 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
 447                  handle later.  */
 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);
 451               return 1;
 452             }
 453         }
 454       break;
 455
 456     case state_error:
 457       /* Just skipping everything.  */
 458       break;
 459     }
 460
 461   return 0;
 462 }
 463
 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.  */
 467
 468 int
 469 eh_frame_estimate_size_before_relax (fragS *frag)
 470 {
 471   offsetT diff;
 472   int ca = frag->fr_subtype >> 3;
 473   int ret;
 474
 475   diff = resolve_symbol_value (frag->fr_symbol);
 476
 477   assert (ca > 0);
 478   diff /= ca;
 479   if (diff < 0x40)
 480     ret = 0;
 481   else if (diff < 0x100)
 482     ret = 1;
 483   else if (diff < 0x10000)
 484     ret = 2;
 485   else
 486     ret = 4;
 487
 488   frag->fr_subtype = (frag->fr_subtype & ~7) | ret;
 489
 490   return ret;
 491 }
 492
 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.  */
 496
 497 int
 498 eh_frame_relax_frag (fragS *frag)
 499 {
 500   int oldsize, newsize;
 501
 502   oldsize = frag->fr_subtype & 7;
 503   newsize = eh_frame_estimate_size_before_relax (frag);
 504   return newsize - oldsize;
 505 }
 506
 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.  */
 510
 511 void
 512 eh_frame_convert_frag (fragS *frag)
 513 {
 514   offsetT diff;
 515   fragS *loc4_frag;
 516   int loc4_fix, ca;
 517
 518   loc4_frag = (fragS *) frag->fr_opcode;
 519   loc4_fix = (int) frag->fr_offset;
 520
 521   diff = resolve_symbol_value (frag->fr_symbol);
 522
 523   ca = frag->fr_subtype >> 3;
 524   assert (ca > 0);
 525   diff /= ca;
 526   switch (frag->fr_subtype & 7)
 527     {
 528     case 0:
 529       assert (diff < 0x40);
 530       loc4_frag->fr_literal[loc4_fix] = DW_CFA_advance_loc | diff;
 531       break;
 532
 533     case 1:
 534       assert (diff < 0x100);
 535       loc4_frag->fr_literal[loc4_fix] = DW_CFA_advance_loc1;
 536       frag->fr_literal[frag->fr_fix] = diff;
 537       break;
 538
 539     case 2:
 540       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);
 543       break;
 544
 545     default:
 546       md_number_to_chars (frag->fr_literal + frag->fr_fix, diff, 4);
 547       break;
 548     }
 549
 550   frag->fr_fix += frag->fr_subtype & 7;
 551   frag->fr_type = rs_fill;
 552   frag->fr_subtype = 0;
 553   frag->fr_offset = 0;
 554 }