gas/ehopt.c

   1 /* ehopt.c--optimize gcc exception frame information.
   2    Copyright 1998, 2000, 2001 Free Software Foundation, Inc.
   3    Written by Ian Lance Taylor <ian@cygnus.com>.
   4
   5 This file is part of GAS, the GNU Assembler.
   6
   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)
  10 any later version.
  11
  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.
  16
  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
  20 02111-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
  91 struct cie_info
  92 {
  93   unsigned code_alignment;
  94   int z_augmentation;
  95 };
  96
  97 static int get_cie_info PARAMS ((struct cie_info *));
  98
  99 /* Extract information from the CIE.  */
 100
 101 static int
 102 get_cie_info (info)
 103      struct cie_info *info;
 104 {
 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
 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)
 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)
 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)
 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)
 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)
 219         return 0;
 220     }
 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;
 228   if ((code_alignment & 0x80) != 0)
 229     code_alignment = 0;
 230
 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
 250 int
 251 check_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;
 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
 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.  */
 302       d->state = state_idle;
 303     }
 304
 305   switch (d->state)
 306     {
 307     case state_idle:
 308       if (*pnbytes == 4)
 309         {
 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         }
 326       break;
 327
 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
 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
 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         {
 353           d->aug_size = exp->X_add_number;
 354           d->state = state_skipping_aug;
 355         }
 356       else if (*pnbytes == 1 && exp->X_op == O_constant)
 357         {
 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         }
 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         {
 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         }
 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         {
 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         }
 393       break;
 394
 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
 434           if (d->cie_info.code_alignment > 0)
 435             fr_subtype = d->cie_info.code_alignment << 3;
 436           else
 437             fr_subtype = 0;
 438
 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     }
 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
 455    relaxation loop.  We set fr_subtype{0:2} to the expected length.  */
 456
 457 int
 458 eh_frame_estimate_size_before_relax (frag)
 459      fragS *frag;
 460 {
 461   offsetT diff;
 462   int ca = frag->fr_subtype >> 3;
 463   int ret;
 464
 465   diff = resolve_symbol_value (frag->fr_symbol);
 466
 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
 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
 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
 485 int
 486 eh_frame_relax_frag (frag)
 487      fragS *frag;
 488 {
 489   int oldsize, newsize;
 490
 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.
 498    fr_subtype{0:2} will be the desired length of the frag.  */
 499
 500 void
 501 eh_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);
 512
 513   switch (frag->fr_subtype & 7)
 514     {
 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
 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;
 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     }
 539
 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 }