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 } 557