gas/ehopt.c

   1 /* ehopt.c--optimize gcc exception frame information.
   2    Copyright (C) 1998-2016 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 3, 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, 51 Franklin Street - Fifth Floor, Boston, MA
  20    02110-1301, USA.  */
  21
  22 #include "as.h"
  23 #include "subsegs.h"
  24 #include "struc-symbol.h"
  25
  26 /* We include this ELF file, even though we may not be assembling for
  27    ELF, since the exception frame information is always in a format
  28    derived from DWARF.  */
  29
  30 #include "dwarf2.h"
  31
  32 /* Try to optimize gcc 2.8 exception frame information.
  33
  34    Exception frame information is emitted for every function in the
  35    .eh_frame or .debug_frame sections.  Simple information for a function
  36    with no exceptions looks like this:
  37
  38 __FRAME_BEGIN__:
  39         .4byte  .LLCIE1 / Length of Common Information Entry
  40 .LSCIE1:
  41 #if .eh_frame
  42         .4byte  0x0     / CIE Identifier Tag
  43 #elif .debug_frame
  44         .4byte  0xffffffff / CIE Identifier Tag
  45 #endif
  46         .byte   0x1     / CIE Version
  47         .byte   0x0     / CIE Augmentation (none)
  48         .byte   0x1     / ULEB128 0x1 (CIE Code Alignment Factor)
  49         .byte   0x7c    / SLEB128 -4 (CIE Data Alignment Factor)
  50         .byte   0x8     / CIE RA Column
  51         .byte   0xc     / DW_CFA_def_cfa
  52         .byte   0x4     / ULEB128 0x4
  53         .byte   0x4     / ULEB128 0x4
  54         .byte   0x88    / DW_CFA_offset, column 0x8
  55         .byte   0x1     / ULEB128 0x1
  56         .align 4
  57 .LECIE1:
  58         .set    .LLCIE1,.LECIE1-.LSCIE1 / CIE Length Symbol
  59         .4byte  .LLFDE1 / FDE Length
  60 .LSFDE1:
  61         .4byte  .LSFDE1-__FRAME_BEGIN__ / FDE CIE offset
  62         .4byte  .LFB1   / FDE initial location
  63         .4byte  .LFE1-.LFB1     / FDE address range
  64         .byte   0x4     / DW_CFA_advance_loc4
  65         .4byte  .LCFI0-.LFB1
  66         .byte   0xe     / DW_CFA_def_cfa_offset
  67         .byte   0x8     / ULEB128 0x8
  68         .byte   0x85    / DW_CFA_offset, column 0x5
  69         .byte   0x2     / ULEB128 0x2
  70         .byte   0x4     / DW_CFA_advance_loc4
  71         .4byte  .LCFI1-.LCFI0
  72         .byte   0xd     / DW_CFA_def_cfa_register
  73         .byte   0x5     / ULEB128 0x5
  74         .byte   0x4     / DW_CFA_advance_loc4
  75         .4byte  .LCFI2-.LCFI1
  76         .byte   0x2e    / DW_CFA_GNU_args_size
  77         .byte   0x4     / ULEB128 0x4
  78         .byte   0x4     / DW_CFA_advance_loc4
  79         .4byte  .LCFI3-.LCFI2
  80         .byte   0x2e    / DW_CFA_GNU_args_size
  81         .byte   0x0     / ULEB128 0x0
  82         .align 4
  83 .LEFDE1:
  84         .set    .LLFDE1,.LEFDE1-.LSFDE1 / FDE Length Symbol
  85
  86    The immediate issue we can address in the assembler is the
  87    DW_CFA_advance_loc4 followed by a four byte value.  The value is
  88    the difference of two addresses in the function.  Since gcc does
  89    not know this value, it always uses four bytes.  We will know the
  90    value at the end of assembly, so we can do better.  */
  91
  92 struct cie_info
  93 {
  94   unsigned code_alignment;
  95   int z_augmentation;
  96 };
  97
  98 static int get_cie_info (struct cie_info *);
  99
 100 /* Extract information from the CIE.  */
 101
 102 static int
 103 get_cie_info (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   f = seg_info (now_seg)->frchainP->frch_root;
 116   fix = seg_info (now_seg)->frchainP->fix_root;
 117
 118   /* Look through the frags of the section to find the code alignment.  */
 119
 120   /* First make sure that the CIE Identifier Tag is 0/-1.  */
 121
 122   if (strncmp (segment_name (now_seg), ".debug_frame", 12) == 0)
 123     CIE_id = (char)0xff;
 124   else
 125     CIE_id = 0;
 126
 127   offset = 4;
 128   while (f != NULL && offset >= f->fr_fix)
 129     {
 130       offset -= f->fr_fix;
 131       f = f->fr_next;
 132     }
 133   if (f == NULL
 134       || f->fr_fix - offset < 4
 135       || f->fr_literal[offset] != CIE_id
 136       || f->fr_literal[offset + 1] != CIE_id
 137       || f->fr_literal[offset + 2] != CIE_id
 138       || f->fr_literal[offset + 3] != CIE_id)
 139     return 0;
 140
 141   /* Next make sure the CIE version number is 1.  */
 142
 143   offset += 4;
 144   while (f != NULL && offset >= f->fr_fix)
 145     {
 146       offset -= f->fr_fix;
 147       f = f->fr_next;
 148     }
 149   if (f == NULL
 150       || f->fr_fix - offset < 1
 151       || f->fr_literal[offset] != 1)
 152     return 0;
 153
 154   /* Skip the augmentation (a null terminated string).  */
 155
 156   iaug = 0;
 157   ++offset;
 158   while (1)
 159     {
 160       while (f != NULL && offset >= f->fr_fix)
 161         {
 162           offset -= f->fr_fix;
 163           f = f->fr_next;
 164         }
 165       if (f == NULL)
 166         return 0;
 167
 168       while (offset < f->fr_fix && f->fr_literal[offset] != '\0')
 169         {
 170           if ((size_t) iaug < (sizeof augmentation) - 1)
 171             {
 172               augmentation[iaug] = f->fr_literal[offset];
 173               ++iaug;
 174             }
 175           ++offset;
 176         }
 177       if (offset < f->fr_fix)
 178         break;
 179     }
 180   ++offset;
 181   while (f != NULL && offset >= f->fr_fix)
 182     {
 183       offset -= f->fr_fix;
 184       f = f->fr_next;
 185     }
 186   if (f == NULL)
 187     return 0;
 188
 189   augmentation[iaug] = '\0';
 190   if (augmentation[0] == '\0')
 191     {
 192       /* No augmentation.  */
 193     }
 194   else if (strcmp (augmentation, "eh") == 0)
 195     {
 196       /* We have to skip a pointer.  Unfortunately, we don't know how
 197          large it is.  We find out by looking for a matching fixup.  */
 198       while (fix != NULL
 199              && (fix->fx_frag != f || fix->fx_where != offset))
 200         fix = fix->fx_next;
 201       if (fix == NULL)
 202         offset += 4;
 203       else
 204         offset += fix->fx_size;
 205       while (f != NULL && offset >= f->fr_fix)
 206         {
 207           offset -= f->fr_fix;
 208           f = f->fr_next;
 209         }
 210       if (f == NULL)
 211         return 0;
 212     }
 213   else if (augmentation[0] != 'z')
 214     return 0;
 215
 216   /* We're now at the code alignment factor, which is a ULEB128.  If
 217      it isn't a single byte, forget it.  */
 218
 219   code_alignment = f->fr_literal[offset] & 0xff;
 220   if ((code_alignment & 0x80) != 0)
 221     code_alignment = 0;
 222
 223   info->code_alignment = code_alignment;
 224   info->z_augmentation = (augmentation[0] == 'z');
 225
 226   return 1;
 227 }
 228
 229 enum frame_state
 230 {
 231   state_idle,
 232   state_saw_size,
 233   state_saw_cie_offset,
 234   state_saw_pc_begin,
 235   state_seeing_aug_size,
 236   state_skipping_aug,
 237   state_wait_loc4,
 238   state_saw_loc4,
 239   state_error,
 240 };
 241
 242 /* This function is called from emit_expr.  It looks for cases which
 243    we can optimize.
 244
 245    Rather than try to parse all this information as we read it, we
 246    look for a single byte DW_CFA_advance_loc4 followed by a 4 byte
 247    difference.  We turn that into a rs_cfa_advance frag, and handle
 248    those frags at the end of the assembly.  If the gcc output changes
 249    somewhat, this optimization may stop working.
 250
 251    This function returns non-zero if it handled the expression and
 252    emit_expr should not do anything, or zero otherwise.  It can also
 253    change *EXP and *PNBYTES.  */
 254
 255 int
 256 check_eh_frame (expressionS *exp, unsigned int *pnbytes)
 257 {
 258   struct frame_data
 259   {
 260     enum frame_state state;
 261
 262     int cie_info_ok;
 263     struct cie_info cie_info;
 264
 265     symbolS *size_end_sym;
 266     fragS *loc4_frag;
 267     int loc4_fix;
 268
 269     int aug_size;
 270     int aug_shift;
 271   };
 272
 273   static struct frame_data eh_frame_data;
 274   static struct frame_data debug_frame_data;
 275   struct frame_data *d;
 276
 277   /* Don't optimize.  */
 278   if (flag_traditional_format)
 279     return 0;
 280
 281 #ifdef md_allow_eh_opt
 282   if (! md_allow_eh_opt)
 283     return 0;
 284 #endif
 285
 286   /* Select the proper section data.  */
 287   if (strncmp (segment_name (now_seg), ".eh_frame", 9) == 0
 288       && segment_name (now_seg)[9] != '_')
 289     d = &eh_frame_data;
 290   else if (strncmp (segment_name (now_seg), ".debug_frame", 12) == 0)
 291     d = &debug_frame_data;
 292   else
 293     return 0;
 294
 295   if (d->state >= state_saw_size && S_IS_DEFINED (d->size_end_sym))
 296     {
 297       /* We have come to the end of the CIE or FDE.  See below where
 298          we set saw_size.  We must check this first because we may now
 299          be looking at the next size.  */
 300       d->state = state_idle;
 301     }
 302
 303   switch (d->state)
 304     {
 305     case state_idle:
 306       if (*pnbytes == 4)
 307         {
 308           /* This might be the size of the CIE or FDE.  We want to know
 309              the size so that we don't accidentally optimize across an FDE
 310              boundary.  We recognize the size in one of two forms: a
 311              symbol which will later be defined as a difference, or a
 312              subtraction of two symbols.  Either way, we can tell when we
 313              are at the end of the FDE because the symbol becomes defined
 314              (in the case of a subtraction, the end symbol, from which the
 315              start symbol is being subtracted).  Other ways of describing
 316              the size will not be optimized.  */
 317           if ((exp->X_op == O_symbol || exp->X_op == O_subtract)
 318               && ! S_IS_DEFINED (exp->X_add_symbol))
 319             {
 320               d->state = state_saw_size;
 321               d->size_end_sym = exp->X_add_symbol;
 322             }
 323         }
 324       break;
 325
 326     case state_saw_size:
 327     case state_saw_cie_offset:
 328       /* Assume whatever form it appears in, it appears atomically.  */
 329       d->state = (enum frame_state) (d->state + 1);
 330       break;
 331
 332     case state_saw_pc_begin:
 333       /* Decide whether we should see an augmentation.  */
 334       if (! d->cie_info_ok
 335           && ! (d->cie_info_ok = get_cie_info (&d->cie_info)))
 336         d->state = state_error;
 337       else if (d->cie_info.z_augmentation)
 338         {
 339           d->state = state_seeing_aug_size;
 340           d->aug_size = 0;
 341           d->aug_shift = 0;
 342         }
 343       else
 344         d->state = state_wait_loc4;
 345       break;
 346
 347     case state_seeing_aug_size:
 348       /* Bytes == -1 means this comes from an leb128 directive.  */
 349       if ((int)*pnbytes == -1 && exp->X_op == O_constant)
 350         {
 351           d->aug_size = exp->X_add_number;
 352           d->state = state_skipping_aug;
 353         }
 354       else if (*pnbytes == 1 && exp->X_op == O_constant)
 355         {
 356           unsigned char byte = exp->X_add_number;
 357           d->aug_size |= (byte & 0x7f) << d->aug_shift;
 358           d->aug_shift += 7;
 359           if ((byte & 0x80) == 0)
 360             d->state = state_skipping_aug;
 361         }
 362       else
 363         d->state = state_error;
 364       if (d->state == state_skipping_aug && d->aug_size == 0)
 365         d->state = state_wait_loc4;
 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 (exp->X_add_number < 0x40)
 406             {
 407               d->loc4_frag->fr_literal[d->loc4_fix]
 408                 = DW_CFA_advance_loc | exp->X_add_number;
 409               /* No more bytes needed.  */
 410               return 1;
 411             }
 412           else if (exp->X_add_number < 0x100)
 413             {
 414               d->loc4_frag->fr_literal[d->loc4_fix] = DW_CFA_advance_loc1;
 415               *pnbytes = 1;
 416             }
 417           else if (exp->X_add_number < 0x10000)
 418             {
 419               d->loc4_frag->fr_literal[d->loc4_fix] = DW_CFA_advance_loc2;
 420               *pnbytes = 2;
 421             }
 422         }
 423       else if (exp->X_op == O_subtract && d->cie_info.code_alignment == 1)
 424         {
 425           /* This is a case we can optimize.  The expression was not
 426              reduced, so we can not finish the optimization until the end
 427              of the assembly.  We set up a variant frag which we handle
 428              later.  */
 429           frag_var (rs_cfa, 4, 0, 1 << 3, make_expr_symbol (exp),
 430                     d->loc4_fix, (char *) d->loc4_frag);
 431           return 1;
 432         }
 433       else if ((exp->X_op == O_divide
 434                 || exp->X_op == O_right_shift)
 435                && d->cie_info.code_alignment > 1)
 436         {
 437           if (exp->X_add_symbol->bsym
 438               && exp->X_op_symbol->bsym
 439               && exp->X_add_symbol->sy_value.X_op == O_subtract
 440               && exp->X_op_symbol->sy_value.X_op == O_constant
 441               && ((exp->X_op == O_divide
 442                    ? exp->X_op_symbol->sy_value.X_add_number
 443                    : (offsetT) 1 << exp->X_op_symbol->sy_value.X_add_number)
 444                   == (offsetT) d->cie_info.code_alignment))
 445             {
 446               /* This is a case we can optimize as well.  The expression was
 447                  not reduced, so we can not finish the optimization until the
 448                  end of the assembly.  We set up a variant frag which we
 449                  handle later.  */
 450               frag_var (rs_cfa, 4, 0, d->cie_info.code_alignment << 3,
 451                         make_expr_symbol (&exp->X_add_symbol->sy_value),
 452                         d->loc4_fix, (char *) d->loc4_frag);
 453               return 1;
 454             }
 455         }
 456       break;
 457
 458     case state_error:
 459       /* Just skipping everything.  */
 460       break;
 461     }
 462
 463   return 0;
 464 }
 465
 466 /* The function estimates the size of a rs_cfa variant frag based on
 467    the current values of the symbols.  It is called before the
 468    relaxation loop.  We set fr_subtype{0:2} to the expected length.  */
 469
 470 int
 471 eh_frame_estimate_size_before_relax (fragS *frag)
 472 {
 473   offsetT diff;
 474   int ca = frag->fr_subtype >> 3;
 475   int ret;
 476
 477   diff = resolve_symbol_value (frag->fr_symbol);
 478
 479   gas_assert (ca > 0);
 480   diff /= ca;
 481   if (diff < 0x40)
 482     ret = 0;
 483   else if (diff < 0x100)
 484     ret = 1;
 485   else if (diff < 0x10000)
 486     ret = 2;
 487   else
 488     ret = 4;
 489
 490   frag->fr_subtype = (frag->fr_subtype & ~7) | ret;
 491
 492   return ret;
 493 }
 494
 495 /* This function relaxes a rs_cfa variant frag based on the current
 496    values of the symbols.  fr_subtype{0:2} is the current length of
 497    the frag.  This returns the change in frag length.  */
 498
 499 int
 500 eh_frame_relax_frag (fragS *frag)
 501 {
 502   int oldsize, newsize;
 503
 504   oldsize = frag->fr_subtype & 7;
 505   newsize = eh_frame_estimate_size_before_relax (frag);
 506   return newsize - oldsize;
 507 }
 508
 509 /* This function converts a rs_cfa variant frag into a normal fill
 510    frag.  This is called after all relaxation has been done.
 511    fr_subtype{0:2} will be the desired length of the frag.  */
 512
 513 void
 514 eh_frame_convert_frag (fragS *frag)
 515 {
 516   offsetT diff;
 517   fragS *loc4_frag;
 518   int loc4_fix, ca;
 519
 520   loc4_frag = (fragS *) frag->fr_opcode;
 521   loc4_fix = (int) frag->fr_offset;
 522
 523   diff = resolve_symbol_value (frag->fr_symbol);
 524
 525   ca = frag->fr_subtype >> 3;
 526   gas_assert (ca > 0);
 527   diff /= ca;
 528   switch (frag->fr_subtype & 7)
 529     {
 530     case 0:
 531       gas_assert (diff < 0x40);
 532       loc4_frag->fr_literal[loc4_fix] = DW_CFA_advance_loc | diff;
 533       break;
 534
 535     case 1:
 536       gas_assert (diff < 0x100);
 537       loc4_frag->fr_literal[loc4_fix] = DW_CFA_advance_loc1;
 538       frag->fr_literal[frag->fr_fix] = diff;
 539       break;
 540
 541     case 2:
 542       gas_assert (diff < 0x10000);
 543       loc4_frag->fr_literal[loc4_fix] = DW_CFA_advance_loc2;
 544       md_number_to_chars (frag->fr_literal + frag->fr_fix, diff, 2);
 545       break;
 546
 547     default:
 548       md_number_to_chars (frag->fr_literal + frag->fr_fix, diff, 4);
 549       break;
 550     }
 551
 552   frag->fr_fix += frag->fr_subtype & 7;
 553   frag->fr_type = rs_fill;
 554   frag->fr_subtype = 0;
 555   frag->fr_offset = 0;
 556 }