gas/ehopt.c

   1 /* ehopt.c--optimize gcc exception frame information.
   2    Copyright (C) 1998-2023 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
  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 "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 /* Extract information from the CIE.  */
  98
  99 static int
 100 get_cie_info (struct cie_info *info)
 101 {
 102   fragS *f;
 103   fixS *fix;
 104   unsigned int offset;
 105   char CIE_id;
 106   char augmentation[10];
 107   int iaug;
 108   int code_alignment = 0;
 109
 110   /* We should find the CIE at the start of the section.  */
 111
 112   f = seg_info (now_seg)->frchainP->frch_root;
 113   fix = seg_info (now_seg)->frchainP->fix_root;
 114
 115   /* Look through the frags of the section to find the code alignment.  */
 116
 117   /* First make sure that the CIE Identifier Tag is 0/-1.  */
 118
 119   if (startswith (segment_name (now_seg), ".debug_frame"))
 120     CIE_id = (char)0xff;
 121   else
 122     CIE_id = 0;
 123
 124   offset = 4;
 125   while (f != NULL && offset >= f->fr_fix)
 126     {
 127       offset -= f->fr_fix;
 128       f = f->fr_next;
 129     }
 130   if (f == NULL
 131       || f->fr_fix - offset < 4
 132       || f->fr_literal[offset] != CIE_id
 133       || f->fr_literal[offset + 1] != CIE_id
 134       || f->fr_literal[offset + 2] != CIE_id
 135       || f->fr_literal[offset + 3] != CIE_id)
 136     return 0;
 137
 138   /* Next make sure the CIE version number is 1.  */
 139
 140   offset += 4;
 141   while (f != NULL && offset >= f->fr_fix)
 142     {
 143       offset -= f->fr_fix;
 144       f = f->fr_next;
 145     }
 146   if (f == NULL
 147       || f->fr_fix - offset < 1
 148       || f->fr_literal[offset] != 1)
 149     return 0;
 150
 151   /* Skip the augmentation (a null terminated string).  */
 152
 153   iaug = 0;
 154   ++offset;
 155   while (1)
 156     {
 157       while (f != NULL && offset >= f->fr_fix)
 158         {
 159           offset -= f->fr_fix;
 160           f = f->fr_next;
 161         }
 162       if (f == NULL)
 163         return 0;
 164
 165       while (offset < f->fr_fix && f->fr_literal[offset] != '\0')
 166         {
 167           if ((size_t) iaug < (sizeof augmentation) - 1)
 168             {
 169               augmentation[iaug] = f->fr_literal[offset];
 170               ++iaug;
 171             }
 172           ++offset;
 173         }
 174       if (offset < f->fr_fix)
 175         break;
 176     }
 177   ++offset;
 178   while (f != NULL && offset >= f->fr_fix)
 179     {
 180       offset -= f->fr_fix;
 181       f = f->fr_next;
 182     }
 183   if (f == NULL)
 184     return 0;
 185
 186   augmentation[iaug] = '\0';
 187   if (augmentation[0] == '\0')
 188     {
 189       /* No augmentation.  */
 190     }
 191   else if (strcmp (augmentation, "eh") == 0)
 192     {
 193       /* We have to skip a pointer.  Unfortunately, we don't know how
 194          large it is.  We find out by looking for a matching fixup.  */
 195       while (fix != NULL
 196              && (fix->fx_frag != f || fix->fx_where != offset))
 197         fix = fix->fx_next;
 198       if (fix == NULL)
 199         offset += 4;
 200       else
 201         offset += fix->fx_size;
 202       while (f != NULL && offset >= f->fr_fix)
 203         {
 204           offset -= f->fr_fix;
 205           f = f->fr_next;
 206         }
 207       if (f == NULL)
 208         return 0;
 209     }
 210   else if (augmentation[0] != 'z')
 211     return 0;
 212
 213   /* We're now at the code alignment factor, which is a ULEB128.  If
 214      it isn't a single byte, forget it.  */
 215
 216   code_alignment = f->fr_literal[offset] & 0xff;
 217   if ((code_alignment & 0x80) != 0)
 218     code_alignment = 0;
 219
 220   info->code_alignment = code_alignment;
 221   info->z_augmentation = (augmentation[0] == 'z');
 222
 223   return 1;
 224 }
 225
 226 enum frame_state
 227 {
 228   state_idle,
 229   state_saw_size,
 230   state_saw_cie_offset,
 231   state_saw_pc_begin,
 232   state_seeing_aug_size,
 233   state_skipping_aug,
 234   state_wait_loc4,
 235   state_saw_loc4,
 236   state_error,
 237 };
 238
 239 struct frame_data
 240 {
 241   enum frame_state state;
 242
 243   int cie_info_ok;
 244   struct cie_info cie_info;
 245
 246   symbolS *size_end_sym;
 247   fragS *loc4_frag;
 248   int loc4_fix;
 249
 250   int aug_size;
 251   int aug_shift;
 252 };
 253
 254 static struct eh_state
 255 {
 256   struct frame_data eh_data;
 257   struct frame_data debug_data;
 258 } frame;
 259
 260 /* This function is called from emit_expr.  It looks for cases which
 261    we can optimize.
 262
 263    Rather than try to parse all this information as we read it, we
 264    look for a single byte DW_CFA_advance_loc4 followed by a 4 byte
 265    difference.  We turn that into a rs_cfa_advance frag, and handle
 266    those frags at the end of the assembly.  If the gcc output changes
 267    somewhat, this optimization may stop working.
 268
 269    This function returns non-zero if it handled the expression and
 270    emit_expr should not do anything, or zero otherwise.  It can also
 271    change *EXP and *PNBYTES.  */
 272
 273 int
 274 check_eh_frame (expressionS *exp, unsigned int *pnbytes)
 275 {
 276   struct frame_data *d;
 277
 278   /* Don't optimize.  */
 279   if (flag_traditional_format)
 280     return 0;
 281
 282 #ifdef md_allow_eh_opt
 283   if (! md_allow_eh_opt)
 284     return 0;
 285 #endif
 286
 287   /* Select the proper section data.  */
 288   if (startswith (segment_name (now_seg), ".eh_frame")
 289       && segment_name (now_seg)[9] != '_')
 290     d = &frame.eh_data;
 291   else if (startswith (segment_name (now_seg), ".debug_frame"))
 292     d = &frame.debug_data;
 293   else
 294     return 0;
 295
 296   if (d->state >= state_saw_size && S_IS_DEFINED (d->size_end_sym))
 297     {
 298       /* We have come to the end of the CIE or FDE.  See below where
 299          we set saw_size.  We must check this first because we may now
 300          be looking at the next size.  */
 301       d->state = state_idle;
 302     }
 303
 304   switch (d->state)
 305     {
 306     case state_idle:
 307       if (*pnbytes == 4)
 308         {
 309           /* This might be the size of the CIE or FDE.  We want to know
 310              the size so that we don't accidentally optimize across an FDE
 311              boundary.  We recognize the size in one of two forms: a
 312              symbol which will later be defined as a difference, or a
 313              subtraction of two symbols.  Either way, we can tell when we
 314              are at the end of the FDE because the symbol becomes defined
 315              (in the case of a subtraction, the end symbol, from which the
 316              start symbol is being subtracted).  Other ways of describing
 317              the size will not be optimized.  */
 318           if ((exp->X_op == O_symbol || exp->X_op == O_subtract)
 319               && ! S_IS_DEFINED (exp->X_add_symbol))
 320             {
 321               d->state = state_saw_size;
 322               d->size_end_sym = exp->X_add_symbol;
 323             }
 324         }
 325       break;
 326
 327     case state_saw_size:
 328     case state_saw_cie_offset:
 329       /* Assume whatever form it appears in, it appears atomically.  */
 330       d->state = (enum frame_state) (d->state + 1);
 331       break;
 332
 333     case state_saw_pc_begin:
 334       /* Decide whether we should see an augmentation.  */
 335       if (! d->cie_info_ok
 336           && ! (d->cie_info_ok = get_cie_info (&d->cie_info)))
 337         d->state = state_error;
 338       else if (d->cie_info.z_augmentation)
 339         {
 340           d->state = state_seeing_aug_size;
 341           d->aug_size = 0;
 342           d->aug_shift = 0;
 343         }
 344       else
 345         d->state = state_wait_loc4;
 346       break;
 347
 348     case state_seeing_aug_size:
 349       /* Bytes == -1 means this comes from an leb128 directive.  */
 350       if ((int)*pnbytes == -1 && exp->X_op == O_constant)
 351         {
 352           d->aug_size = exp->X_add_number;
 353           d->state = state_skipping_aug;
 354         }
 355       else if (*pnbytes == 1 && exp->X_op == O_constant)
 356         {
 357           unsigned char byte = exp->X_add_number;
 358           d->aug_size |= (byte & 0x7f) << d->aug_shift;
 359           d->aug_shift += 7;
 360           if ((byte & 0x80) == 0)
 361             d->state = state_skipping_aug;
 362         }
 363       else
 364         d->state = state_error;
 365       if (d->state == state_skipping_aug && d->aug_size == 0)
 366         d->state = state_wait_loc4;
 367       break;
 368
 369     case state_skipping_aug:
 370       if ((int)*pnbytes < 0)
 371         d->state = state_error;
 372       else
 373         {
 374           int left = (d->aug_size -= *pnbytes);
 375           if (left == 0)
 376             d->state = state_wait_loc4;
 377           else if (left < 0)
 378             d->state = state_error;
 379         }
 380       break;
 381
 382     case state_wait_loc4:
 383       if (*pnbytes == 1
 384           && exp->X_op == O_constant
 385           && exp->X_add_number == DW_CFA_advance_loc4)
 386         {
 387           /* This might be a DW_CFA_advance_loc4.  Record the frag and the
 388              position within the frag, so that we can change it later.  */
 389           frag_grow (1 + 4);
 390           d->state = state_saw_loc4;
 391           d->loc4_frag = frag_now;
 392           d->loc4_fix = frag_now_fix ();
 393         }
 394       break;
 395
 396     case state_saw_loc4:
 397       d->state = state_wait_loc4;
 398       if (*pnbytes != 4)
 399         break;
 400       if (exp->X_op == O_constant)
 401         {
 402           /* This is a case which we can optimize.  The two symbols being
 403              subtracted were in the same frag and the expression was
 404              reduced to a constant.  We can do the optimization entirely
 405              in this function.  */
 406           if (exp->X_add_number < 0x40)
 407             {
 408               d->loc4_frag->fr_literal[d->loc4_fix]
 409                 = DW_CFA_advance_loc | exp->X_add_number;
 410               /* No more bytes needed.  */
 411               return 1;
 412             }
 413           else if (exp->X_add_number < 0x100)
 414             {
 415               d->loc4_frag->fr_literal[d->loc4_fix] = DW_CFA_advance_loc1;
 416               *pnbytes = 1;
 417             }
 418           else if (exp->X_add_number < 0x10000)
 419             {
 420               d->loc4_frag->fr_literal[d->loc4_fix] = DW_CFA_advance_loc2;
 421               *pnbytes = 2;
 422             }
 423         }
 424       else if (exp->X_op == O_subtract && d->cie_info.code_alignment == 1)
 425         {
 426           /* This is a case we can optimize.  The expression was not
 427              reduced, so we can not finish the optimization until the end
 428              of the assembly.  We set up a variant frag which we handle
 429              later.  */
 430           frag_var (rs_cfa, 4, 0, 1 << 3, make_expr_symbol (exp),
 431                     d->loc4_fix, (char *) d->loc4_frag);
 432           return 1;
 433         }
 434       else if ((exp->X_op == O_divide
 435                 || exp->X_op == O_right_shift)
 436                && d->cie_info.code_alignment > 1)
 437         {
 438           if (symbol_symbolS (exp->X_add_symbol)
 439               && symbol_constant_p (exp->X_op_symbol)
 440               && S_GET_SEGMENT (exp->X_op_symbol) == absolute_section
 441               && ((exp->X_op == O_divide
 442                    ? *symbol_X_add_number (exp->X_op_symbol)
 443                    : (offsetT) 1 << *symbol_X_add_number (exp->X_op_symbol))
 444                   == (offsetT) d->cie_info.code_alignment))
 445             {
 446               expressionS *symval;
 447
 448               symval = symbol_get_value_expression (exp->X_add_symbol);
 449               if (symval->X_op == O_subtract)
 450                 {
 451                   /* This is a case we can optimize as well.  The
 452                      expression was not reduced, so we can not finish
 453                      the optimization until the end of the assembly.
 454                      We set up a variant frag which we handle later.  */
 455                   frag_var (rs_cfa, 4, 0, d->cie_info.code_alignment << 3,
 456                             make_expr_symbol (symval),
 457                             d->loc4_fix, (char *) d->loc4_frag);
 458                   return 1;
 459                 }
 460             }
 461         }
 462       break;
 463
 464     case state_error:
 465       /* Just skipping everything.  */
 466       break;
 467     }
 468
 469   return 0;
 470 }
 471
 472 /* The function estimates the size of a rs_cfa variant frag based on
 473    the current values of the symbols.  It is called before the
 474    relaxation loop.  We set fr_subtype{0:2} to the expected length.  */
 475
 476 int
 477 eh_frame_estimate_size_before_relax (fragS *frag)
 478 {
 479   offsetT diff;
 480   int ca = frag->fr_subtype >> 3;
 481   int ret;
 482
 483   diff = resolve_symbol_value (frag->fr_symbol);
 484
 485   gas_assert (ca > 0);
 486   diff /= ca;
 487   if (diff == 0)
 488     ret = -1;
 489   else if (diff < 0x40)
 490     ret = 0;
 491   else if (diff < 0x100)
 492     ret = 1;
 493   else if (diff < 0x10000)
 494     ret = 2;
 495   else
 496     ret = 4;
 497
 498   frag->fr_subtype = (frag->fr_subtype & ~7) | (ret & 7);
 499
 500   return ret;
 501 }
 502
 503 /* This function relaxes a rs_cfa variant frag based on the current
 504    values of the symbols.  fr_subtype{0:2} is the current length of
 505    the frag.  This returns the change in frag length.  */
 506
 507 int
 508 eh_frame_relax_frag (fragS *frag)
 509 {
 510   int oldsize, newsize;
 511
 512   oldsize = frag->fr_subtype & 7;
 513   if (oldsize == 7)
 514     oldsize = -1;
 515   newsize = eh_frame_estimate_size_before_relax (frag);
 516   return newsize - oldsize;
 517 }
 518
 519 /* This function converts a rs_cfa variant frag into a normal fill
 520    frag.  This is called after all relaxation has been done.
 521    fr_subtype{0:2} will be the desired length of the frag.  */
 522
 523 void
 524 eh_frame_convert_frag (fragS *frag)
 525 {
 526   offsetT diff;
 527   fragS *loc4_frag;
 528   int loc4_fix, ca;
 529
 530   loc4_frag = (fragS *) frag->fr_opcode;
 531   loc4_fix = (int) frag->fr_offset;
 532
 533   diff = resolve_symbol_value (frag->fr_symbol);
 534
 535   ca = frag->fr_subtype >> 3;
 536   gas_assert (ca > 0);
 537   diff /= ca;
 538   switch (frag->fr_subtype & 7)
 539     {
 540     case 0:
 541       gas_assert (diff < 0x40);
 542       loc4_frag->fr_literal[loc4_fix] = DW_CFA_advance_loc | diff;
 543       break;
 544
 545     case 1:
 546       gas_assert (diff < 0x100);
 547       loc4_frag->fr_literal[loc4_fix] = DW_CFA_advance_loc1;
 548       frag->fr_literal[frag->fr_fix] = diff;
 549       break;
 550
 551     case 2:
 552       gas_assert (diff < 0x10000);
 553       loc4_frag->fr_literal[loc4_fix] = DW_CFA_advance_loc2;
 554       md_number_to_chars (frag->fr_literal + frag->fr_fix, diff, 2);
 555       break;
 556
 557     case 4:
 558       md_number_to_chars (frag->fr_literal + frag->fr_fix, diff, 4);
 559       break;
 560
 561     case 7:
 562       gas_assert (diff == 0);
 563       frag->fr_fix -= 8;
 564       break;
 565
 566     default:
 567       abort ();
 568     }
 569
 570   frag->fr_fix += frag->fr_subtype & 7;
 571   frag->fr_type = rs_fill;
 572   frag->fr_subtype = 0;
 573   frag->fr_offset = 0;
 574 }
 575
 576 void
 577 eh_begin (void)
 578 {
 579   memset (&frame, 0, sizeof (frame));
 580 }