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