1 /* DWARF2 exception handling and frame unwind runtime interface routines. 2 Copyright (C) 1997-2018 Free Software Foundation, Inc. 3 4 This file is part of GCC. 5 6 GCC is free software; you can redistribute it and/or modify it 7 under the terms of the GNU General Public License as published by 8 the Free Software Foundation; either version 3, or (at your option) 9 any later version. 10 11 GCC is distributed in the hope that it will be useful, but WITHOUT 12 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY 13 or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public 14 License for more details. 15 16 Under Section 7 of GPL version 3, you are granted additional 17 permissions described in the GCC Runtime Library Exception, version 18 3.1, as published by the Free Software Foundation. 19 20 You should have received a copy of the GNU General Public License and 21 a copy of the GCC Runtime Library Exception along with this program; 22 see the files COPYING3 and COPYING.RUNTIME respectively. If not, see 23 <http://www.gnu.org/licenses/>. */ 24 25 #include "tconfig.h" 26 #include "tsystem.h" 27 #include "coretypes.h" 28 #include "tm.h" 29 #include "libgcc_tm.h" 30 #include "dwarf2.h" 31 #include "unwind.h" 32 #ifdef __USING_SJLJ_EXCEPTIONS__ 33 # define NO_SIZE_OF_ENCODED_VALUE 34 #endif 35 #include "unwind-pe.h" 36 #include "unwind-dw2-fde.h" 37 #include "gthr.h" 38 #include "unwind-dw2.h" 39 40 #ifdef HAVE_SYS_SDT_H 41 #include <sys/sdt.h> 42 #endif 43 44 #ifndef __USING_SJLJ_EXCEPTIONS__ 45 46 #ifndef __LIBGCC_STACK_GROWS_DOWNWARD__ 47 #define __LIBGCC_STACK_GROWS_DOWNWARD__ 0 48 #else 49 #undef __LIBGCC_STACK_GROWS_DOWNWARD__ 50 #define __LIBGCC_STACK_GROWS_DOWNWARD__ 1 51 #endif 52 53 /* Dwarf frame registers used for pre gcc 3.0 compiled glibc. */ 54 #ifndef PRE_GCC3_DWARF_FRAME_REGISTERS 55 #define PRE_GCC3_DWARF_FRAME_REGISTERS __LIBGCC_DWARF_FRAME_REGISTERS__ 56 #endif 57 58 /* ??? For the public function interfaces, we tend to gcc_assert that the 59 column numbers are in range. For the dwarf2 unwind info this does happen, 60 although so far in a case that doesn't actually matter. 61 62 See PR49146, in which a call from x86_64 ms abi to x86_64 unix abi stores 63 the call-saved xmm registers and annotates them. We havn't bothered 64 providing support for the xmm registers for the x86_64 port primarily 65 because the 64-bit windows targets don't use dwarf2 unwind, using sjlj or 66 SEH instead. Adding the support for unix targets would generally be a 67 waste. However, some runtime libraries supplied with ICC do contain such 68 an unorthodox transition, as well as the unwind info to match. This loss 69 of register restoration doesn't matter in practice, because the exception 70 is caught in the native unix abi, where all of the xmm registers are 71 call clobbered. 72 73 Ideally, we'd record some bit to notice when we're failing to restore some 74 register recorded in the unwind info, but to do that we need annotation on 75 the unix->ms abi edge, so that we know when the register data may be 76 discarded. And since this edge is also within the ICC library, we're 77 unlikely to be able to get the new annotation. 78 79 Barring a magic solution to restore the ms abi defined 128-bit xmm registers 80 (as distictly opposed to the full runtime width) without causing extra 81 overhead for normal unix abis, the best solution seems to be to simply 82 ignore unwind data for unknown columns. */ 83 84 #define UNWIND_COLUMN_IN_RANGE(x) \ 85 __builtin_expect((x) <= __LIBGCC_DWARF_FRAME_REGISTERS__, 1) 86 87 #ifdef REG_VALUE_IN_UNWIND_CONTEXT 88 typedef _Unwind_Word _Unwind_Context_Reg_Val; 89 90 #ifndef ASSUME_EXTENDED_UNWIND_CONTEXT 91 #define ASSUME_EXTENDED_UNWIND_CONTEXT 1 92 #endif 93 94 static inline _Unwind_Word 95 _Unwind_Get_Unwind_Word (_Unwind_Context_Reg_Val val) 96 { 97 return val; 98 } 99 100 static inline _Unwind_Context_Reg_Val 101 _Unwind_Get_Unwind_Context_Reg_Val (_Unwind_Word val) 102 { 103 return val; 104 } 105 #else 106 typedef void *_Unwind_Context_Reg_Val; 107 108 static inline _Unwind_Word 109 _Unwind_Get_Unwind_Word (_Unwind_Context_Reg_Val val) 110 { 111 return (_Unwind_Word) (_Unwind_Internal_Ptr) val; 112 } 113 114 static inline _Unwind_Context_Reg_Val 115 _Unwind_Get_Unwind_Context_Reg_Val (_Unwind_Word val) 116 { 117 return (_Unwind_Context_Reg_Val) (_Unwind_Internal_Ptr) val; 118 } 119 #endif 120 121 #ifndef ASSUME_EXTENDED_UNWIND_CONTEXT 122 #define ASSUME_EXTENDED_UNWIND_CONTEXT 0 123 #endif 124 125 /* This is the register and unwind state for a particular frame. This 126 provides the information necessary to unwind up past a frame and return 127 to its caller. */ 128 struct _Unwind_Context 129 { 130 _Unwind_Context_Reg_Val reg[__LIBGCC_DWARF_FRAME_REGISTERS__+1]; 131 void *cfa; 132 void *ra; 133 void *lsda; 134 struct dwarf_eh_bases bases; 135 /* Signal frame context. */ 136 #define SIGNAL_FRAME_BIT ((~(_Unwind_Word) 0 >> 1) + 1) 137 /* Context which has version/args_size/by_value fields. */ 138 #define EXTENDED_CONTEXT_BIT ((~(_Unwind_Word) 0 >> 2) + 1) 139 /* Bit reserved on AArch64, return address has been signed with A key. */ 140 #define RA_A_SIGNED_BIT ((~(_Unwind_Word) 0 >> 3) + 1) 141 _Unwind_Word flags; 142 /* 0 for now, can be increased when further fields are added to 143 struct _Unwind_Context. */ 144 _Unwind_Word version; 145 _Unwind_Word args_size; 146 char by_value[__LIBGCC_DWARF_FRAME_REGISTERS__+1]; 147 }; 148 149 /* Byte size of every register managed by these routines. */ 150 static unsigned char dwarf_reg_size_table[__LIBGCC_DWARF_FRAME_REGISTERS__+1]; 151 152 153 /* Read unaligned data from the instruction buffer. */ 154 155 union unaligned 156 { 157 void *p; 158 unsigned u2 __attribute__ ((mode (HI))); 159 unsigned u4 __attribute__ ((mode (SI))); 160 unsigned u8 __attribute__ ((mode (DI))); 161 signed s2 __attribute__ ((mode (HI))); 162 signed s4 __attribute__ ((mode (SI))); 163 signed s8 __attribute__ ((mode (DI))); 164 } __attribute__ ((packed)); 165 166 static void uw_update_context (struct _Unwind_Context *, _Unwind_FrameState *); 167 static _Unwind_Reason_Code uw_frame_state_for (struct _Unwind_Context *, 168 _Unwind_FrameState *); 169 170 static inline void * 171 read_pointer (const void *p) { const union unaligned *up = p; return up->p; } 172 173 static inline int 174 read_1u (const void *p) { return *(const unsigned char *) p; } 175 176 static inline int 177 read_1s (const void *p) { return *(const signed char *) p; } 178 179 static inline int 180 read_2u (const void *p) { const union unaligned *up = p; return up->u2; } 181 182 static inline int 183 read_2s (const void *p) { const union unaligned *up = p; return up->s2; } 184 185 static inline unsigned int 186 read_4u (const void *p) { const union unaligned *up = p; return up->u4; } 187 188 static inline int 189 read_4s (const void *p) { const union unaligned *up = p; return up->s4; } 190 191 static inline unsigned long 192 read_8u (const void *p) { const union unaligned *up = p; return up->u8; } 193 194 static inline unsigned long 195 read_8s (const void *p) { const union unaligned *up = p; return up->s8; } 196 197 static inline _Unwind_Word 198 _Unwind_IsSignalFrame (struct _Unwind_Context *context) 199 { 200 return (context->flags & SIGNAL_FRAME_BIT) ? 1 : 0; 201 } 202 203 static inline void 204 _Unwind_SetSignalFrame (struct _Unwind_Context *context, int val) 205 { 206 if (val) 207 context->flags |= SIGNAL_FRAME_BIT; 208 else 209 context->flags &= ~SIGNAL_FRAME_BIT; 210 } 211 212 static inline _Unwind_Word 213 _Unwind_IsExtendedContext (struct _Unwind_Context *context) 214 { 215 return (ASSUME_EXTENDED_UNWIND_CONTEXT 216 || (context->flags & EXTENDED_CONTEXT_BIT)); 217 } 218 219 /* Get the value of register REGNO as saved in CONTEXT. */ 220 221 inline _Unwind_Word 222 _Unwind_GetGR (struct _Unwind_Context *context, int regno) 223 { 224 int size, index; 225 _Unwind_Context_Reg_Val val; 226 227 #ifdef DWARF_ZERO_REG 228 if (regno == DWARF_ZERO_REG) 229 return 0; 230 #endif 231 232 index = DWARF_REG_TO_UNWIND_COLUMN (regno); 233 gcc_assert (index < (int) sizeof(dwarf_reg_size_table)); 234 size = dwarf_reg_size_table[index]; 235 val = context->reg[index]; 236 237 if (_Unwind_IsExtendedContext (context) && context->by_value[index]) 238 return _Unwind_Get_Unwind_Word (val); 239 240 #ifdef DWARF_LAZY_REGISTER_VALUE 241 { 242 _Unwind_Word value; 243 if (DWARF_LAZY_REGISTER_VALUE (regno, &value)) 244 return value; 245 } 246 #endif 247 248 /* This will segfault if the register hasn't been saved. */ 249 if (size == sizeof(_Unwind_Ptr)) 250 return * (_Unwind_Ptr *) (_Unwind_Internal_Ptr) val; 251 else 252 { 253 gcc_assert (size == sizeof(_Unwind_Word)); 254 return * (_Unwind_Word *) (_Unwind_Internal_Ptr) val; 255 } 256 } 257 258 static inline void * 259 _Unwind_GetPtr (struct _Unwind_Context *context, int index) 260 { 261 return (void *)(_Unwind_Ptr) _Unwind_GetGR (context, index); 262 } 263 264 /* Get the value of the CFA as saved in CONTEXT. */ 265 266 _Unwind_Word 267 _Unwind_GetCFA (struct _Unwind_Context *context) 268 { 269 return (_Unwind_Ptr) context->cfa; 270 } 271 272 /* Overwrite the saved value for register INDEX in CONTEXT with VAL. */ 273 274 inline void 275 _Unwind_SetGR (struct _Unwind_Context *context, int index, _Unwind_Word val) 276 { 277 int size; 278 void *ptr; 279 280 index = DWARF_REG_TO_UNWIND_COLUMN (index); 281 gcc_assert (index < (int) sizeof(dwarf_reg_size_table)); 282 size = dwarf_reg_size_table[index]; 283 284 if (_Unwind_IsExtendedContext (context) && context->by_value[index]) 285 { 286 context->reg[index] = _Unwind_Get_Unwind_Context_Reg_Val (val); 287 return; 288 } 289 290 ptr = (void *) (_Unwind_Internal_Ptr) context->reg[index]; 291 292 if (size == sizeof(_Unwind_Ptr)) 293 * (_Unwind_Ptr *) ptr = val; 294 else 295 { 296 gcc_assert (size == sizeof(_Unwind_Word)); 297 * (_Unwind_Word *) ptr = val; 298 } 299 } 300 301 /* Get the pointer to a register INDEX as saved in CONTEXT. */ 302 303 static inline void * 304 _Unwind_GetGRPtr (struct _Unwind_Context *context, int index) 305 { 306 index = DWARF_REG_TO_UNWIND_COLUMN (index); 307 if (_Unwind_IsExtendedContext (context) && context->by_value[index]) 308 return &context->reg[index]; 309 return (void *) (_Unwind_Internal_Ptr) context->reg[index]; 310 } 311 312 /* Set the pointer to a register INDEX as saved in CONTEXT. */ 313 314 static inline void 315 _Unwind_SetGRPtr (struct _Unwind_Context *context, int index, void *p) 316 { 317 index = DWARF_REG_TO_UNWIND_COLUMN (index); 318 if (_Unwind_IsExtendedContext (context)) 319 context->by_value[index] = 0; 320 context->reg[index] = (_Unwind_Context_Reg_Val) (_Unwind_Internal_Ptr) p; 321 } 322 323 /* Overwrite the saved value for register INDEX in CONTEXT with VAL. */ 324 325 static inline void 326 _Unwind_SetGRValue (struct _Unwind_Context *context, int index, 327 _Unwind_Word val) 328 { 329 index = DWARF_REG_TO_UNWIND_COLUMN (index); 330 gcc_assert (index < (int) sizeof(dwarf_reg_size_table)); 331 /* Return column size may be smaller than _Unwind_Context_Reg_Val. */ 332 gcc_assert (dwarf_reg_size_table[index] <= sizeof (_Unwind_Context_Reg_Val)); 333 334 context->by_value[index] = 1; 335 context->reg[index] = _Unwind_Get_Unwind_Context_Reg_Val (val); 336 } 337 338 /* Return nonzero if register INDEX is stored by value rather than 339 by reference. */ 340 341 static inline int 342 _Unwind_GRByValue (struct _Unwind_Context *context, int index) 343 { 344 index = DWARF_REG_TO_UNWIND_COLUMN (index); 345 return context->by_value[index]; 346 } 347 348 /* Retrieve the return address for CONTEXT. */ 349 350 inline _Unwind_Ptr 351 _Unwind_GetIP (struct _Unwind_Context *context) 352 { 353 return (_Unwind_Ptr) context->ra; 354 } 355 356 /* Retrieve the return address and flag whether that IP is before 357 or after first not yet fully executed instruction. */ 358 359 inline _Unwind_Ptr 360 _Unwind_GetIPInfo (struct _Unwind_Context *context, int *ip_before_insn) 361 { 362 *ip_before_insn = _Unwind_IsSignalFrame (context); 363 return (_Unwind_Ptr) context->ra; 364 } 365 366 /* Overwrite the return address for CONTEXT with VAL. */ 367 368 inline void 369 _Unwind_SetIP (struct _Unwind_Context *context, _Unwind_Ptr val) 370 { 371 context->ra = (void *) val; 372 } 373 374 void * 375 _Unwind_GetLanguageSpecificData (struct _Unwind_Context *context) 376 { 377 return context->lsda; 378 } 379 380 _Unwind_Ptr 381 _Unwind_GetRegionStart (struct _Unwind_Context *context) 382 { 383 return (_Unwind_Ptr) context->bases.func; 384 } 385 386 void * 387 _Unwind_FindEnclosingFunction (void *pc) 388 { 389 struct dwarf_eh_bases bases; 390 const struct dwarf_fde *fde = _Unwind_Find_FDE (pc-1, &bases); 391 if (fde) 392 return bases.func; 393 else 394 return NULL; 395 } 396 397 #ifndef __ia64__ 398 _Unwind_Ptr 399 _Unwind_GetDataRelBase (struct _Unwind_Context *context) 400 { 401 return (_Unwind_Ptr) context->bases.dbase; 402 } 403 404 _Unwind_Ptr 405 _Unwind_GetTextRelBase (struct _Unwind_Context *context) 406 { 407 return (_Unwind_Ptr) context->bases.tbase; 408 } 409 #endif 410 411 #include "md-unwind-support.h" 412 413 /* Extract any interesting information from the CIE for the translation 414 unit F belongs to. Return a pointer to the byte after the augmentation, 415 or NULL if we encountered an undecipherable augmentation. */ 416 417 static const unsigned char * 418 extract_cie_info (const struct dwarf_cie *cie, struct _Unwind_Context *context, 419 _Unwind_FrameState *fs) 420 { 421 const unsigned char *aug = cie->augmentation; 422 const unsigned char *p = aug + strlen ((const char *)aug) + 1; 423 const unsigned char *ret = NULL; 424 _uleb128_t utmp; 425 _sleb128_t stmp; 426 427 /* g++ v2 "eh" has pointer immediately following augmentation string, 428 so it must be handled first. */ 429 if (aug[0] == 'e' && aug[1] == 'h') 430 { 431 fs->eh_ptr = read_pointer (p); 432 p += sizeof (void *); 433 aug += 2; 434 } 435 436 /* After the augmentation resp. pointer for "eh" augmentation 437 follows for CIE version >= 4 address size byte and 438 segment size byte. */ 439 if (__builtin_expect (cie->version >= 4, 0)) 440 { 441 if (p[0] != sizeof (void *) || p[1] != 0) 442 return NULL; 443 p += 2; 444 } 445 /* Immediately following this are the code and 446 data alignment and return address column. */ 447 p = read_uleb128 (p, &utmp); 448 fs->code_align = (_Unwind_Word)utmp; 449 p = read_sleb128 (p, &stmp); 450 fs->data_align = (_Unwind_Sword)stmp; 451 if (cie->version == 1) 452 fs->retaddr_column = *p++; 453 else 454 { 455 p = read_uleb128 (p, &utmp); 456 fs->retaddr_column = (_Unwind_Word)utmp; 457 } 458 fs->lsda_encoding = DW_EH_PE_omit; 459 460 /* If the augmentation starts with 'z', then a uleb128 immediately 461 follows containing the length of the augmentation field following 462 the size. */ 463 if (*aug == 'z') 464 { 465 p = read_uleb128 (p, &utmp); 466 ret = p + utmp; 467 468 fs->saw_z = 1; 469 ++aug; 470 } 471 472 /* Iterate over recognized augmentation subsequences. */ 473 while (*aug != '\0') 474 { 475 /* "L" indicates a byte showing how the LSDA pointer is encoded. */ 476 if (aug[0] == 'L') 477 { 478 fs->lsda_encoding = *p++; 479 aug += 1; 480 } 481 482 /* "R" indicates a byte indicating how FDE addresses are encoded. */ 483 else if (aug[0] == 'R') 484 { 485 fs->fde_encoding = *p++; 486 aug += 1; 487 } 488 489 /* "P" indicates a personality routine in the CIE augmentation. */ 490 else if (aug[0] == 'P') 491 { 492 _Unwind_Ptr personality; 493 494 p = read_encoded_value (context, *p, p + 1, &personality); 495 fs->personality = (_Unwind_Personality_Fn) personality; 496 aug += 1; 497 } 498 499 /* "S" indicates a signal frame. */ 500 else if (aug[0] == 'S') 501 { 502 fs->signal_frame = 1; 503 aug += 1; 504 } 505 506 /* Otherwise we have an unknown augmentation string. 507 Bail unless we saw a 'z' prefix. */ 508 else 509 return ret; 510 } 511 512 return ret ? ret : p; 513 } 514 515 516 /* Decode a DW_OP stack program. Return the top of stack. Push INITIAL 517 onto the stack to start. */ 518 519 static _Unwind_Word 520 execute_stack_op (const unsigned char *op_ptr, const unsigned char *op_end, 521 struct _Unwind_Context *context, _Unwind_Word initial) 522 { 523 _Unwind_Word stack[64]; /* ??? Assume this is enough. */ 524 int stack_elt; 525 526 stack[0] = initial; 527 stack_elt = 1; 528 529 while (op_ptr < op_end) 530 { 531 enum dwarf_location_atom op = *op_ptr++; 532 _Unwind_Word result; 533 _uleb128_t reg, utmp; 534 _sleb128_t offset, stmp; 535 536 switch (op) 537 { 538 case DW_OP_lit0: 539 case DW_OP_lit1: 540 case DW_OP_lit2: 541 case DW_OP_lit3: 542 case DW_OP_lit4: 543 case DW_OP_lit5: 544 case DW_OP_lit6: 545 case DW_OP_lit7: 546 case DW_OP_lit8: 547 case DW_OP_lit9: 548 case DW_OP_lit10: 549 case DW_OP_lit11: 550 case DW_OP_lit12: 551 case DW_OP_lit13: 552 case DW_OP_lit14: 553 case DW_OP_lit15: 554 case DW_OP_lit16: 555 case DW_OP_lit17: 556 case DW_OP_lit18: 557 case DW_OP_lit19: 558 case DW_OP_lit20: 559 case DW_OP_lit21: 560 case DW_OP_lit22: 561 case DW_OP_lit23: 562 case DW_OP_lit24: 563 case DW_OP_lit25: 564 case DW_OP_lit26: 565 case DW_OP_lit27: 566 case DW_OP_lit28: 567 case DW_OP_lit29: 568 case DW_OP_lit30: 569 case DW_OP_lit31: 570 result = op - DW_OP_lit0; 571 break; 572 573 case DW_OP_addr: 574 result = (_Unwind_Word) (_Unwind_Ptr) read_pointer (op_ptr); 575 op_ptr += sizeof (void *); 576 break; 577 578 case DW_OP_GNU_encoded_addr: 579 { 580 _Unwind_Ptr presult; 581 op_ptr = read_encoded_value (context, *op_ptr, op_ptr+1, &presult); 582 result = presult; 583 } 584 break; 585 586 case DW_OP_const1u: 587 result = read_1u (op_ptr); 588 op_ptr += 1; 589 break; 590 case DW_OP_const1s: 591 result = read_1s (op_ptr); 592 op_ptr += 1; 593 break; 594 case DW_OP_const2u: 595 result = read_2u (op_ptr); 596 op_ptr += 2; 597 break; 598 case DW_OP_const2s: 599 result = read_2s (op_ptr); 600 op_ptr += 2; 601 break; 602 case DW_OP_const4u: 603 result = read_4u (op_ptr); 604 op_ptr += 4; 605 break; 606 case DW_OP_const4s: 607 result = read_4s (op_ptr); 608 op_ptr += 4; 609 break; 610 case DW_OP_const8u: 611 result = read_8u (op_ptr); 612 op_ptr += 8; 613 break; 614 case DW_OP_const8s: 615 result = read_8s (op_ptr); 616 op_ptr += 8; 617 break; 618 case DW_OP_constu: 619 op_ptr = read_uleb128 (op_ptr, &utmp); 620 result = (_Unwind_Word)utmp; 621 break; 622 case DW_OP_consts: 623 op_ptr = read_sleb128 (op_ptr, &stmp); 624 result = (_Unwind_Sword)stmp; 625 break; 626 627 case DW_OP_reg0: 628 case DW_OP_reg1: 629 case DW_OP_reg2: 630 case DW_OP_reg3: 631 case DW_OP_reg4: 632 case DW_OP_reg5: 633 case DW_OP_reg6: 634 case DW_OP_reg7: 635 case DW_OP_reg8: 636 case DW_OP_reg9: 637 case DW_OP_reg10: 638 case DW_OP_reg11: 639 case DW_OP_reg12: 640 case DW_OP_reg13: 641 case DW_OP_reg14: 642 case DW_OP_reg15: 643 case DW_OP_reg16: 644 case DW_OP_reg17: 645 case DW_OP_reg18: 646 case DW_OP_reg19: 647 case DW_OP_reg20: 648 case DW_OP_reg21: 649 case DW_OP_reg22: 650 case DW_OP_reg23: 651 case DW_OP_reg24: 652 case DW_OP_reg25: 653 case DW_OP_reg26: 654 case DW_OP_reg27: 655 case DW_OP_reg28: 656 case DW_OP_reg29: 657 case DW_OP_reg30: 658 case DW_OP_reg31: 659 result = _Unwind_GetGR (context, op - DW_OP_reg0); 660 break; 661 case DW_OP_regx: 662 op_ptr = read_uleb128 (op_ptr, ®); 663 result = _Unwind_GetGR (context, reg); 664 break; 665 666 case DW_OP_breg0: 667 case DW_OP_breg1: 668 case DW_OP_breg2: 669 case DW_OP_breg3: 670 case DW_OP_breg4: 671 case DW_OP_breg5: 672 case DW_OP_breg6: 673 case DW_OP_breg7: 674 case DW_OP_breg8: 675 case DW_OP_breg9: 676 case DW_OP_breg10: 677 case DW_OP_breg11: 678 case DW_OP_breg12: 679 case DW_OP_breg13: 680 case DW_OP_breg14: 681 case DW_OP_breg15: 682 case DW_OP_breg16: 683 case DW_OP_breg17: 684 case DW_OP_breg18: 685 case DW_OP_breg19: 686 case DW_OP_breg20: 687 case DW_OP_breg21: 688 case DW_OP_breg22: 689 case DW_OP_breg23: 690 case DW_OP_breg24: 691 case DW_OP_breg25: 692 case DW_OP_breg26: 693 case DW_OP_breg27: 694 case DW_OP_breg28: 695 case DW_OP_breg29: 696 case DW_OP_breg30: 697 case DW_OP_breg31: 698 op_ptr = read_sleb128 (op_ptr, &offset); 699 result = _Unwind_GetGR (context, op - DW_OP_breg0) + offset; 700 break; 701 case DW_OP_bregx: 702 op_ptr = read_uleb128 (op_ptr, ®); 703 op_ptr = read_sleb128 (op_ptr, &offset); 704 result = _Unwind_GetGR (context, reg) + (_Unwind_Word)offset; 705 break; 706 707 case DW_OP_dup: 708 gcc_assert (stack_elt); 709 result = stack[stack_elt - 1]; 710 break; 711 712 case DW_OP_drop: 713 gcc_assert (stack_elt); 714 stack_elt -= 1; 715 goto no_push; 716 717 case DW_OP_pick: 718 offset = *op_ptr++; 719 gcc_assert (offset < stack_elt - 1); 720 result = stack[stack_elt - 1 - offset]; 721 break; 722 723 case DW_OP_over: 724 gcc_assert (stack_elt >= 2); 725 result = stack[stack_elt - 2]; 726 break; 727 728 case DW_OP_swap: 729 { 730 _Unwind_Word t; 731 gcc_assert (stack_elt >= 2); 732 t = stack[stack_elt - 1]; 733 stack[stack_elt - 1] = stack[stack_elt - 2]; 734 stack[stack_elt - 2] = t; 735 goto no_push; 736 } 737 738 case DW_OP_rot: 739 { 740 _Unwind_Word t1, t2, t3; 741 742 gcc_assert (stack_elt >= 3); 743 t1 = stack[stack_elt - 1]; 744 t2 = stack[stack_elt - 2]; 745 t3 = stack[stack_elt - 3]; 746 stack[stack_elt - 1] = t2; 747 stack[stack_elt - 2] = t3; 748 stack[stack_elt - 3] = t1; 749 goto no_push; 750 } 751 752 case DW_OP_deref: 753 case DW_OP_deref_size: 754 case DW_OP_abs: 755 case DW_OP_neg: 756 case DW_OP_not: 757 case DW_OP_plus_uconst: 758 /* Unary operations. */ 759 gcc_assert (stack_elt); 760 stack_elt -= 1; 761 762 result = stack[stack_elt]; 763 764 switch (op) 765 { 766 case DW_OP_deref: 767 { 768 void *ptr = (void *) (_Unwind_Ptr) result; 769 result = (_Unwind_Ptr) read_pointer (ptr); 770 } 771 break; 772 773 case DW_OP_deref_size: 774 { 775 void *ptr = (void *) (_Unwind_Ptr) result; 776 switch (*op_ptr++) 777 { 778 case 1: 779 result = read_1u (ptr); 780 break; 781 case 2: 782 result = read_2u (ptr); 783 break; 784 case 4: 785 result = read_4u (ptr); 786 break; 787 case 8: 788 result = read_8u (ptr); 789 break; 790 default: 791 gcc_unreachable (); 792 } 793 } 794 break; 795 796 case DW_OP_abs: 797 if ((_Unwind_Sword) result < 0) 798 result = -result; 799 break; 800 case DW_OP_neg: 801 result = -result; 802 break; 803 case DW_OP_not: 804 result = ~result; 805 break; 806 case DW_OP_plus_uconst: 807 op_ptr = read_uleb128 (op_ptr, &utmp); 808 result += (_Unwind_Word)utmp; 809 break; 810 811 default: 812 gcc_unreachable (); 813 } 814 break; 815 816 case DW_OP_and: 817 case DW_OP_div: 818 case DW_OP_minus: 819 case DW_OP_mod: 820 case DW_OP_mul: 821 case DW_OP_or: 822 case DW_OP_plus: 823 case DW_OP_shl: 824 case DW_OP_shr: 825 case DW_OP_shra: 826 case DW_OP_xor: 827 case DW_OP_le: 828 case DW_OP_ge: 829 case DW_OP_eq: 830 case DW_OP_lt: 831 case DW_OP_gt: 832 case DW_OP_ne: 833 { 834 /* Binary operations. */ 835 _Unwind_Word first, second; 836 gcc_assert (stack_elt >= 2); 837 stack_elt -= 2; 838 839 second = stack[stack_elt]; 840 first = stack[stack_elt + 1]; 841 842 switch (op) 843 { 844 case DW_OP_and: 845 result = second & first; 846 break; 847 case DW_OP_div: 848 result = (_Unwind_Sword) second / (_Unwind_Sword) first; 849 break; 850 case DW_OP_minus: 851 result = second - first; 852 break; 853 case DW_OP_mod: 854 result = second % first; 855 break; 856 case DW_OP_mul: 857 result = second * first; 858 break; 859 case DW_OP_or: 860 result = second | first; 861 break; 862 case DW_OP_plus: 863 result = second + first; 864 break; 865 case DW_OP_shl: 866 result = second << first; 867 break; 868 case DW_OP_shr: 869 result = second >> first; 870 break; 871 case DW_OP_shra: 872 result = (_Unwind_Sword) second >> first; 873 break; 874 case DW_OP_xor: 875 result = second ^ first; 876 break; 877 case DW_OP_le: 878 result = (_Unwind_Sword) second <= (_Unwind_Sword) first; 879 break; 880 case DW_OP_ge: 881 result = (_Unwind_Sword) second >= (_Unwind_Sword) first; 882 break; 883 case DW_OP_eq: 884 result = (_Unwind_Sword) second == (_Unwind_Sword) first; 885 break; 886 case DW_OP_lt: 887 result = (_Unwind_Sword) second < (_Unwind_Sword) first; 888 break; 889 case DW_OP_gt: 890 result = (_Unwind_Sword) second > (_Unwind_Sword) first; 891 break; 892 case DW_OP_ne: 893 result = (_Unwind_Sword) second != (_Unwind_Sword) first; 894 break; 895 896 default: 897 gcc_unreachable (); 898 } 899 } 900 break; 901 902 case DW_OP_skip: 903 offset = read_2s (op_ptr); 904 op_ptr += 2; 905 op_ptr += offset; 906 goto no_push; 907 908 case DW_OP_bra: 909 gcc_assert (stack_elt); 910 stack_elt -= 1; 911 912 offset = read_2s (op_ptr); 913 op_ptr += 2; 914 if (stack[stack_elt] != 0) 915 op_ptr += offset; 916 goto no_push; 917 918 case DW_OP_nop: 919 goto no_push; 920 921 default: 922 gcc_unreachable (); 923 } 924 925 /* Most things push a result value. */ 926 gcc_assert ((size_t) stack_elt < sizeof(stack)/sizeof(*stack)); 927 stack[stack_elt++] = result; 928 no_push:; 929 } 930 931 /* We were executing this program to get a value. It should be 932 at top of stack. */ 933 gcc_assert (stack_elt); 934 stack_elt -= 1; 935 return stack[stack_elt]; 936 } 937 938 939 /* Decode DWARF 2 call frame information. Takes pointers the 940 instruction sequence to decode, current register information and 941 CIE info, and the PC range to evaluate. */ 942 943 static void 944 execute_cfa_program (const unsigned char *insn_ptr, 945 const unsigned char *insn_end, 946 struct _Unwind_Context *context, 947 _Unwind_FrameState *fs) 948 { 949 struct frame_state_reg_info *unused_rs = NULL; 950 951 /* Don't allow remember/restore between CIE and FDE programs. */ 952 fs->regs.prev = NULL; 953 954 /* The comparison with the return address uses < rather than <= because 955 we are only interested in the effects of code before the call; for a 956 noreturn function, the return address may point to unrelated code with 957 a different stack configuration that we are not interested in. We 958 assume that the call itself is unwind info-neutral; if not, or if 959 there are delay instructions that adjust the stack, these must be 960 reflected at the point immediately before the call insn. 961 In signal frames, return address is after last completed instruction, 962 so we add 1 to return address to make the comparison <=. */ 963 while (insn_ptr < insn_end 964 && fs->pc < context->ra + _Unwind_IsSignalFrame (context)) 965 { 966 unsigned char insn = *insn_ptr++; 967 _uleb128_t reg, utmp; 968 _sleb128_t offset, stmp; 969 970 if ((insn & 0xc0) == DW_CFA_advance_loc) 971 fs->pc += (insn & 0x3f) * fs->code_align; 972 else if ((insn & 0xc0) == DW_CFA_offset) 973 { 974 reg = insn & 0x3f; 975 insn_ptr = read_uleb128 (insn_ptr, &utmp); 976 offset = (_Unwind_Sword) utmp * fs->data_align; 977 reg = DWARF_REG_TO_UNWIND_COLUMN (reg); 978 if (UNWIND_COLUMN_IN_RANGE (reg)) 979 { 980 fs->regs.reg[reg].how = REG_SAVED_OFFSET; 981 fs->regs.reg[reg].loc.offset = offset; 982 } 983 } 984 else if ((insn & 0xc0) == DW_CFA_restore) 985 { 986 reg = insn & 0x3f; 987 reg = DWARF_REG_TO_UNWIND_COLUMN (reg); 988 if (UNWIND_COLUMN_IN_RANGE (reg)) 989 fs->regs.reg[reg].how = REG_UNSAVED; 990 } 991 else switch (insn) 992 { 993 case DW_CFA_set_loc: 994 { 995 _Unwind_Ptr pc; 996 997 insn_ptr = read_encoded_value (context, fs->fde_encoding, 998 insn_ptr, &pc); 999 fs->pc = (void *) pc; 1000 } 1001 break; 1002 1003 case DW_CFA_advance_loc1: 1004 fs->pc += read_1u (insn_ptr) * fs->code_align; 1005 insn_ptr += 1; 1006 break; 1007 case DW_CFA_advance_loc2: 1008 fs->pc += read_2u (insn_ptr) * fs->code_align; 1009 insn_ptr += 2; 1010 break; 1011 case DW_CFA_advance_loc4: 1012 fs->pc += read_4u (insn_ptr) * fs->code_align; 1013 insn_ptr += 4; 1014 break; 1015 1016 case DW_CFA_offset_extended: 1017 insn_ptr = read_uleb128 (insn_ptr, ®); 1018 insn_ptr = read_uleb128 (insn_ptr, &utmp); 1019 offset = (_Unwind_Sword) utmp * fs->data_align; 1020 reg = DWARF_REG_TO_UNWIND_COLUMN (reg); 1021 if (UNWIND_COLUMN_IN_RANGE (reg)) 1022 { 1023 fs->regs.reg[reg].how = REG_SAVED_OFFSET; 1024 fs->regs.reg[reg].loc.offset = offset; 1025 } 1026 break; 1027 1028 case DW_CFA_restore_extended: 1029 insn_ptr = read_uleb128 (insn_ptr, ®); 1030 /* FIXME, this is wrong; the CIE might have said that the 1031 register was saved somewhere. */ 1032 reg = DWARF_REG_TO_UNWIND_COLUMN (reg); 1033 if (UNWIND_COLUMN_IN_RANGE (reg)) 1034 fs->regs.reg[reg].how = REG_UNSAVED; 1035 break; 1036 1037 case DW_CFA_same_value: 1038 insn_ptr = read_uleb128 (insn_ptr, ®); 1039 reg = DWARF_REG_TO_UNWIND_COLUMN (reg); 1040 if (UNWIND_COLUMN_IN_RANGE (reg)) 1041 fs->regs.reg[reg].how = REG_UNSAVED; 1042 break; 1043 1044 case DW_CFA_undefined: 1045 insn_ptr = read_uleb128 (insn_ptr, ®); 1046 reg = DWARF_REG_TO_UNWIND_COLUMN (reg); 1047 if (UNWIND_COLUMN_IN_RANGE (reg)) 1048 fs->regs.reg[reg].how = REG_UNDEFINED; 1049 break; 1050 1051 case DW_CFA_nop: 1052 break; 1053 1054 case DW_CFA_register: 1055 { 1056 _uleb128_t reg2; 1057 insn_ptr = read_uleb128 (insn_ptr, ®); 1058 insn_ptr = read_uleb128 (insn_ptr, ®2); 1059 reg = DWARF_REG_TO_UNWIND_COLUMN (reg); 1060 if (UNWIND_COLUMN_IN_RANGE (reg)) 1061 { 1062 fs->regs.reg[reg].how = REG_SAVED_REG; 1063 fs->regs.reg[reg].loc.reg = (_Unwind_Word)reg2; 1064 } 1065 } 1066 break; 1067 1068 case DW_CFA_remember_state: 1069 { 1070 struct frame_state_reg_info *new_rs; 1071 if (unused_rs) 1072 { 1073 new_rs = unused_rs; 1074 unused_rs = unused_rs->prev; 1075 } 1076 else 1077 new_rs = alloca (sizeof (struct frame_state_reg_info)); 1078 1079 *new_rs = fs->regs; 1080 fs->regs.prev = new_rs; 1081 } 1082 break; 1083 1084 case DW_CFA_restore_state: 1085 { 1086 struct frame_state_reg_info *old_rs = fs->regs.prev; 1087 fs->regs = *old_rs; 1088 old_rs->prev = unused_rs; 1089 unused_rs = old_rs; 1090 } 1091 break; 1092 1093 case DW_CFA_def_cfa: 1094 insn_ptr = read_uleb128 (insn_ptr, &utmp); 1095 fs->regs.cfa_reg = (_Unwind_Word)utmp; 1096 insn_ptr = read_uleb128 (insn_ptr, &utmp); 1097 fs->regs.cfa_offset = (_Unwind_Word)utmp; 1098 fs->regs.cfa_how = CFA_REG_OFFSET; 1099 break; 1100 1101 case DW_CFA_def_cfa_register: 1102 insn_ptr = read_uleb128 (insn_ptr, &utmp); 1103 fs->regs.cfa_reg = (_Unwind_Word)utmp; 1104 fs->regs.cfa_how = CFA_REG_OFFSET; 1105 break; 1106 1107 case DW_CFA_def_cfa_offset: 1108 insn_ptr = read_uleb128 (insn_ptr, &utmp); 1109 fs->regs.cfa_offset = utmp; 1110 /* cfa_how deliberately not set. */ 1111 break; 1112 1113 case DW_CFA_def_cfa_expression: 1114 fs->regs.cfa_exp = insn_ptr; 1115 fs->regs.cfa_how = CFA_EXP; 1116 insn_ptr = read_uleb128 (insn_ptr, &utmp); 1117 insn_ptr += utmp; 1118 break; 1119 1120 case DW_CFA_expression: 1121 insn_ptr = read_uleb128 (insn_ptr, ®); 1122 reg = DWARF_REG_TO_UNWIND_COLUMN (reg); 1123 if (UNWIND_COLUMN_IN_RANGE (reg)) 1124 { 1125 fs->regs.reg[reg].how = REG_SAVED_EXP; 1126 fs->regs.reg[reg].loc.exp = insn_ptr; 1127 } 1128 insn_ptr = read_uleb128 (insn_ptr, &utmp); 1129 insn_ptr += utmp; 1130 break; 1131 1132 /* Dwarf3. */ 1133 case DW_CFA_offset_extended_sf: 1134 insn_ptr = read_uleb128 (insn_ptr, ®); 1135 insn_ptr = read_sleb128 (insn_ptr, &stmp); 1136 offset = stmp * fs->data_align; 1137 reg = DWARF_REG_TO_UNWIND_COLUMN (reg); 1138 if (UNWIND_COLUMN_IN_RANGE (reg)) 1139 { 1140 fs->regs.reg[reg].how = REG_SAVED_OFFSET; 1141 fs->regs.reg[reg].loc.offset = offset; 1142 } 1143 break; 1144 1145 case DW_CFA_def_cfa_sf: 1146 insn_ptr = read_uleb128 (insn_ptr, &utmp); 1147 fs->regs.cfa_reg = (_Unwind_Word)utmp; 1148 insn_ptr = read_sleb128 (insn_ptr, &stmp); 1149 fs->regs.cfa_offset = (_Unwind_Sword)stmp; 1150 fs->regs.cfa_how = CFA_REG_OFFSET; 1151 fs->regs.cfa_offset *= fs->data_align; 1152 break; 1153 1154 case DW_CFA_def_cfa_offset_sf: 1155 insn_ptr = read_sleb128 (insn_ptr, &stmp); 1156 fs->regs.cfa_offset = (_Unwind_Sword)stmp; 1157 fs->regs.cfa_offset *= fs->data_align; 1158 /* cfa_how deliberately not set. */ 1159 break; 1160 1161 case DW_CFA_val_offset: 1162 insn_ptr = read_uleb128 (insn_ptr, ®); 1163 insn_ptr = read_uleb128 (insn_ptr, &utmp); 1164 offset = (_Unwind_Sword) utmp * fs->data_align; 1165 reg = DWARF_REG_TO_UNWIND_COLUMN (reg); 1166 if (UNWIND_COLUMN_IN_RANGE (reg)) 1167 { 1168 fs->regs.reg[reg].how = REG_SAVED_VAL_OFFSET; 1169 fs->regs.reg[reg].loc.offset = offset; 1170 } 1171 break; 1172 1173 case DW_CFA_val_offset_sf: 1174 insn_ptr = read_uleb128 (insn_ptr, ®); 1175 insn_ptr = read_sleb128 (insn_ptr, &stmp); 1176 offset = stmp * fs->data_align; 1177 reg = DWARF_REG_TO_UNWIND_COLUMN (reg); 1178 if (UNWIND_COLUMN_IN_RANGE (reg)) 1179 { 1180 fs->regs.reg[reg].how = REG_SAVED_VAL_OFFSET; 1181 fs->regs.reg[reg].loc.offset = offset; 1182 } 1183 break; 1184 1185 case DW_CFA_val_expression: 1186 insn_ptr = read_uleb128 (insn_ptr, ®); 1187 reg = DWARF_REG_TO_UNWIND_COLUMN (reg); 1188 if (UNWIND_COLUMN_IN_RANGE (reg)) 1189 { 1190 fs->regs.reg[reg].how = REG_SAVED_VAL_EXP; 1191 fs->regs.reg[reg].loc.exp = insn_ptr; 1192 } 1193 insn_ptr = read_uleb128 (insn_ptr, &utmp); 1194 insn_ptr += utmp; 1195 break; 1196 1197 case DW_CFA_GNU_window_save: 1198 #if defined (__aarch64__) && !defined (__ILP32__) 1199 /* This CFA is multiplexed with Sparc. On AArch64 it's used to toggle 1200 return address signing status. */ 1201 fs->regs.reg[DWARF_REGNUM_AARCH64_RA_STATE].loc.offset ^= 1; 1202 #else 1203 /* ??? Hardcoded for SPARC register window configuration. */ 1204 if (__LIBGCC_DWARF_FRAME_REGISTERS__ >= 32) 1205 for (reg = 16; reg < 32; ++reg) 1206 { 1207 fs->regs.reg[reg].how = REG_SAVED_OFFSET; 1208 fs->regs.reg[reg].loc.offset = (reg - 16) * sizeof (void *); 1209 } 1210 #endif 1211 break; 1212 1213 case DW_CFA_GNU_args_size: 1214 insn_ptr = read_uleb128 (insn_ptr, &utmp); 1215 context->args_size = (_Unwind_Word)utmp; 1216 break; 1217 1218 case DW_CFA_GNU_negative_offset_extended: 1219 /* Obsoleted by DW_CFA_offset_extended_sf, but used by 1220 older PowerPC code. */ 1221 insn_ptr = read_uleb128 (insn_ptr, ®); 1222 insn_ptr = read_uleb128 (insn_ptr, &utmp); 1223 offset = (_Unwind_Word) utmp * fs->data_align; 1224 reg = DWARF_REG_TO_UNWIND_COLUMN (reg); 1225 if (UNWIND_COLUMN_IN_RANGE (reg)) 1226 { 1227 fs->regs.reg[reg].how = REG_SAVED_OFFSET; 1228 fs->regs.reg[reg].loc.offset = -offset; 1229 } 1230 break; 1231 1232 default: 1233 gcc_unreachable (); 1234 } 1235 } 1236 } 1237 1238 /* Given the _Unwind_Context CONTEXT for a stack frame, look up the FDE for 1239 its caller and decode it into FS. This function also sets the 1240 args_size and lsda members of CONTEXT, as they are really information 1241 about the caller's frame. */ 1242 1243 static _Unwind_Reason_Code 1244 uw_frame_state_for (struct _Unwind_Context *context, _Unwind_FrameState *fs) 1245 { 1246 const struct dwarf_fde *fde; 1247 const struct dwarf_cie *cie; 1248 const unsigned char *aug, *insn, *end; 1249 1250 memset (fs, 0, sizeof (*fs)); 1251 context->args_size = 0; 1252 context->lsda = 0; 1253 1254 if (context->ra == 0) 1255 return _URC_END_OF_STACK; 1256 1257 fde = _Unwind_Find_FDE (context->ra + _Unwind_IsSignalFrame (context) - 1, 1258 &context->bases); 1259 if (fde == NULL) 1260 { 1261 #ifdef MD_FALLBACK_FRAME_STATE_FOR 1262 /* Couldn't find frame unwind info for this function. Try a 1263 target-specific fallback mechanism. This will necessarily 1264 not provide a personality routine or LSDA. */ 1265 return MD_FALLBACK_FRAME_STATE_FOR (context, fs); 1266 #else 1267 return _URC_END_OF_STACK; 1268 #endif 1269 } 1270 1271 fs->pc = context->bases.func; 1272 1273 cie = get_cie (fde); 1274 insn = extract_cie_info (cie, context, fs); 1275 if (insn == NULL) 1276 /* CIE contained unknown augmentation. */ 1277 return _URC_FATAL_PHASE1_ERROR; 1278 1279 /* First decode all the insns in the CIE. */ 1280 end = (const unsigned char *) next_fde ((const struct dwarf_fde *) cie); 1281 execute_cfa_program (insn, end, context, fs); 1282 1283 /* Locate augmentation for the fde. */ 1284 aug = (const unsigned char *) fde + sizeof (*fde); 1285 aug += 2 * size_of_encoded_value (fs->fde_encoding); 1286 insn = NULL; 1287 if (fs->saw_z) 1288 { 1289 _uleb128_t i; 1290 aug = read_uleb128 (aug, &i); 1291 insn = aug + i; 1292 } 1293 if (fs->lsda_encoding != DW_EH_PE_omit) 1294 { 1295 _Unwind_Ptr lsda; 1296 1297 aug = read_encoded_value (context, fs->lsda_encoding, aug, &lsda); 1298 context->lsda = (void *) lsda; 1299 } 1300 1301 /* Then the insns in the FDE up to our target PC. */ 1302 if (insn == NULL) 1303 insn = aug; 1304 end = (const unsigned char *) next_fde (fde); 1305 execute_cfa_program (insn, end, context, fs); 1306 1307 return _URC_NO_REASON; 1308 } 1309 1310 typedef struct frame_state 1311 { 1312 void *cfa; 1313 void *eh_ptr; 1314 long cfa_offset; 1315 long args_size; 1316 long reg_or_offset[PRE_GCC3_DWARF_FRAME_REGISTERS+1]; 1317 unsigned short cfa_reg; 1318 unsigned short retaddr_column; 1319 char saved[PRE_GCC3_DWARF_FRAME_REGISTERS+1]; 1320 } frame_state; 1321 1322 struct frame_state * __frame_state_for (void *, struct frame_state *); 1323 1324 /* Called from pre-G++ 3.0 __throw to find the registers to restore for 1325 a given PC_TARGET. The caller should allocate a local variable of 1326 `struct frame_state' and pass its address to STATE_IN. */ 1327 1328 struct frame_state * 1329 __frame_state_for (void *pc_target, struct frame_state *state_in) 1330 { 1331 struct _Unwind_Context context; 1332 _Unwind_FrameState fs; 1333 int reg; 1334 1335 memset (&context, 0, sizeof (struct _Unwind_Context)); 1336 if (!ASSUME_EXTENDED_UNWIND_CONTEXT) 1337 context.flags = EXTENDED_CONTEXT_BIT; 1338 context.ra = pc_target + 1; 1339 1340 if (uw_frame_state_for (&context, &fs) != _URC_NO_REASON) 1341 return 0; 1342 1343 /* We have no way to pass a location expression for the CFA to our 1344 caller. It wouldn't understand it anyway. */ 1345 if (fs.regs.cfa_how == CFA_EXP) 1346 return 0; 1347 1348 for (reg = 0; reg < PRE_GCC3_DWARF_FRAME_REGISTERS + 1; reg++) 1349 { 1350 state_in->saved[reg] = fs.regs.reg[reg].how; 1351 switch (state_in->saved[reg]) 1352 { 1353 case REG_SAVED_REG: 1354 state_in->reg_or_offset[reg] = fs.regs.reg[reg].loc.reg; 1355 break; 1356 case REG_SAVED_OFFSET: 1357 state_in->reg_or_offset[reg] = fs.regs.reg[reg].loc.offset; 1358 break; 1359 default: 1360 state_in->reg_or_offset[reg] = 0; 1361 break; 1362 } 1363 } 1364 1365 state_in->cfa_offset = fs.regs.cfa_offset; 1366 state_in->cfa_reg = fs.regs.cfa_reg; 1367 state_in->retaddr_column = fs.retaddr_column; 1368 state_in->args_size = context.args_size; 1369 state_in->eh_ptr = fs.eh_ptr; 1370 1371 return state_in; 1372 } 1373 1374 typedef union { _Unwind_Ptr ptr; _Unwind_Word word; } _Unwind_SpTmp; 1375 1376 static inline void 1377 _Unwind_SetSpColumn (struct _Unwind_Context *context, void *cfa, 1378 _Unwind_SpTmp *tmp_sp) 1379 { 1380 int size = dwarf_reg_size_table[__builtin_dwarf_sp_column ()]; 1381 1382 if (size == sizeof(_Unwind_Ptr)) 1383 tmp_sp->ptr = (_Unwind_Ptr) cfa; 1384 else 1385 { 1386 gcc_assert (size == sizeof(_Unwind_Word)); 1387 tmp_sp->word = (_Unwind_Ptr) cfa; 1388 } 1389 _Unwind_SetGRPtr (context, __builtin_dwarf_sp_column (), tmp_sp); 1390 } 1391 1392 static void 1393 uw_update_context_1 (struct _Unwind_Context *context, _Unwind_FrameState *fs) 1394 { 1395 struct _Unwind_Context orig_context = *context; 1396 void *cfa; 1397 long i; 1398 1399 #ifdef __LIBGCC_EH_RETURN_STACKADJ_RTX__ 1400 /* Special handling here: Many machines do not use a frame pointer, 1401 and track the CFA only through offsets from the stack pointer from 1402 one frame to the next. In this case, the stack pointer is never 1403 stored, so it has no saved address in the context. What we do 1404 have is the CFA from the previous stack frame. 1405 1406 In very special situations (such as unwind info for signal return), 1407 there may be location expressions that use the stack pointer as well. 1408 1409 Do this conditionally for one frame. This allows the unwind info 1410 for one frame to save a copy of the stack pointer from the previous 1411 frame, and be able to use much easier CFA mechanisms to do it. 1412 Always zap the saved stack pointer value for the next frame; carrying 1413 the value over from one frame to another doesn't make sense. */ 1414 1415 _Unwind_SpTmp tmp_sp; 1416 1417 if (!_Unwind_GetGRPtr (&orig_context, __builtin_dwarf_sp_column ())) 1418 _Unwind_SetSpColumn (&orig_context, context->cfa, &tmp_sp); 1419 _Unwind_SetGRPtr (context, __builtin_dwarf_sp_column (), NULL); 1420 #endif 1421 1422 /* Compute this frame's CFA. */ 1423 switch (fs->regs.cfa_how) 1424 { 1425 case CFA_REG_OFFSET: 1426 cfa = _Unwind_GetPtr (&orig_context, fs->regs.cfa_reg); 1427 cfa += fs->regs.cfa_offset; 1428 break; 1429 1430 case CFA_EXP: 1431 { 1432 const unsigned char *exp = fs->regs.cfa_exp; 1433 _uleb128_t len; 1434 1435 exp = read_uleb128 (exp, &len); 1436 cfa = (void *) (_Unwind_Ptr) 1437 execute_stack_op (exp, exp + len, &orig_context, 0); 1438 break; 1439 } 1440 1441 default: 1442 gcc_unreachable (); 1443 } 1444 context->cfa = cfa; 1445 1446 /* Compute the addresses of all registers saved in this frame. */ 1447 for (i = 0; i < __LIBGCC_DWARF_FRAME_REGISTERS__ + 1; ++i) 1448 switch (fs->regs.reg[i].how) 1449 { 1450 case REG_UNSAVED: 1451 case REG_UNDEFINED: 1452 break; 1453 1454 case REG_SAVED_OFFSET: 1455 _Unwind_SetGRPtr (context, i, 1456 (void *) (cfa + fs->regs.reg[i].loc.offset)); 1457 break; 1458 1459 case REG_SAVED_REG: 1460 if (_Unwind_GRByValue (&orig_context, fs->regs.reg[i].loc.reg)) 1461 _Unwind_SetGRValue (context, i, 1462 _Unwind_GetGR (&orig_context, 1463 fs->regs.reg[i].loc.reg)); 1464 else 1465 _Unwind_SetGRPtr (context, i, 1466 _Unwind_GetGRPtr (&orig_context, 1467 fs->regs.reg[i].loc.reg)); 1468 break; 1469 1470 case REG_SAVED_EXP: 1471 { 1472 const unsigned char *exp = fs->regs.reg[i].loc.exp; 1473 _uleb128_t len; 1474 _Unwind_Ptr val; 1475 1476 exp = read_uleb128 (exp, &len); 1477 val = execute_stack_op (exp, exp + len, &orig_context, 1478 (_Unwind_Ptr) cfa); 1479 _Unwind_SetGRPtr (context, i, (void *) val); 1480 } 1481 break; 1482 1483 case REG_SAVED_VAL_OFFSET: 1484 _Unwind_SetGRValue (context, i, 1485 (_Unwind_Internal_Ptr) 1486 (cfa + fs->regs.reg[i].loc.offset)); 1487 break; 1488 1489 case REG_SAVED_VAL_EXP: 1490 { 1491 const unsigned char *exp = fs->regs.reg[i].loc.exp; 1492 _uleb128_t len; 1493 _Unwind_Ptr val; 1494 1495 exp = read_uleb128 (exp, &len); 1496 val = execute_stack_op (exp, exp + len, &orig_context, 1497 (_Unwind_Ptr) cfa); 1498 _Unwind_SetGRValue (context, i, val); 1499 } 1500 break; 1501 } 1502 1503 _Unwind_SetSignalFrame (context, fs->signal_frame); 1504 1505 #ifdef MD_FROB_UPDATE_CONTEXT 1506 MD_FROB_UPDATE_CONTEXT (context, fs); 1507 #endif 1508 } 1509 1510 /* CONTEXT describes the unwind state for a frame, and FS describes the FDE 1511 of its caller. Update CONTEXT to refer to the caller as well. Note 1512 that the args_size and lsda members are not updated here, but later in 1513 uw_frame_state_for. */ 1514 1515 static void 1516 uw_update_context (struct _Unwind_Context *context, _Unwind_FrameState *fs) 1517 { 1518 uw_update_context_1 (context, fs); 1519 1520 /* In general this unwinder doesn't make any distinction between 1521 undefined and same_value rule. Call-saved registers are assumed 1522 to have same_value rule by default and explicit undefined 1523 rule is handled like same_value. The only exception is 1524 DW_CFA_undefined on retaddr_column which is supposed to 1525 mark outermost frame in DWARF 3. */ 1526 if (fs->regs.reg[DWARF_REG_TO_UNWIND_COLUMN (fs->retaddr_column)].how 1527 == REG_UNDEFINED) 1528 /* uw_frame_state_for uses context->ra == 0 check to find outermost 1529 stack frame. */ 1530 context->ra = 0; 1531 else 1532 { 1533 /* Compute the return address now, since the return address column 1534 can change from frame to frame. */ 1535 context->ra = __builtin_extract_return_addr 1536 (_Unwind_GetPtr (context, fs->retaddr_column)); 1537 #ifdef MD_POST_EXTRACT_FRAME_ADDR 1538 context->ra = MD_POST_EXTRACT_FRAME_ADDR (context, fs, context->ra); 1539 #endif 1540 } 1541 } 1542 1543 static void 1544 uw_advance_context (struct _Unwind_Context *context, _Unwind_FrameState *fs) 1545 { 1546 uw_update_context (context, fs); 1547 } 1548 1549 /* Fill in CONTEXT for top-of-stack. The only valid registers at this 1550 level will be the return address and the CFA. */ 1551 1552 #define uw_init_context(CONTEXT) \ 1553 do \ 1554 { \ 1555 /* Do any necessary initialization to access arbitrary stack frames. \ 1556 On the SPARC, this means flushing the register windows. */ \ 1557 __builtin_unwind_init (); \ 1558 uw_init_context_1 (CONTEXT, __builtin_dwarf_cfa (), \ 1559 __builtin_return_address (0)); \ 1560 } \ 1561 while (0) 1562 1563 static inline void 1564 init_dwarf_reg_size_table (void) 1565 { 1566 __builtin_init_dwarf_reg_size_table (dwarf_reg_size_table); 1567 } 1568 1569 static void __attribute__((noinline)) 1570 uw_init_context_1 (struct _Unwind_Context *context, 1571 void *outer_cfa, void *outer_ra) 1572 { 1573 void *ra = __builtin_extract_return_addr (__builtin_return_address (0)); 1574 #ifdef MD_POST_EXTRACT_ROOT_ADDR 1575 ra = MD_POST_EXTRACT_ROOT_ADDR (ra); 1576 #endif 1577 _Unwind_FrameState fs; 1578 _Unwind_SpTmp sp_slot; 1579 _Unwind_Reason_Code code; 1580 1581 memset (context, 0, sizeof (struct _Unwind_Context)); 1582 context->ra = ra; 1583 if (!ASSUME_EXTENDED_UNWIND_CONTEXT) 1584 context->flags = EXTENDED_CONTEXT_BIT; 1585 1586 code = uw_frame_state_for (context, &fs); 1587 gcc_assert (code == _URC_NO_REASON); 1588 1589 #if __GTHREADS 1590 { 1591 static __gthread_once_t once_regsizes = __GTHREAD_ONCE_INIT; 1592 if (__gthread_once (&once_regsizes, init_dwarf_reg_size_table) != 0 1593 && dwarf_reg_size_table[0] == 0) 1594 init_dwarf_reg_size_table (); 1595 } 1596 #else 1597 if (dwarf_reg_size_table[0] == 0) 1598 init_dwarf_reg_size_table (); 1599 #endif 1600 1601 /* Force the frame state to use the known cfa value. */ 1602 _Unwind_SetSpColumn (context, outer_cfa, &sp_slot); 1603 fs.regs.cfa_how = CFA_REG_OFFSET; 1604 fs.regs.cfa_reg = __builtin_dwarf_sp_column (); 1605 fs.regs.cfa_offset = 0; 1606 1607 uw_update_context_1 (context, &fs); 1608 1609 /* If the return address column was saved in a register in the 1610 initialization context, then we can't see it in the given 1611 call frame data. So have the initialization context tell us. */ 1612 context->ra = __builtin_extract_return_addr (outer_ra); 1613 #ifdef MD_POST_EXTRACT_ROOT_ADDR 1614 context->ra = MD_POST_EXTRACT_ROOT_ADDR (context->ra); 1615 #endif 1616 } 1617 1618 static void _Unwind_DebugHook (void *, void *) 1619 __attribute__ ((__noinline__, __used__, __noclone__)); 1620 1621 /* This function is called during unwinding. It is intended as a hook 1622 for a debugger to intercept exceptions. CFA is the CFA of the 1623 target frame. HANDLER is the PC to which control will be 1624 transferred. */ 1625 static void 1626 _Unwind_DebugHook (void *cfa __attribute__ ((__unused__)), 1627 void *handler __attribute__ ((__unused__))) 1628 { 1629 /* We only want to use stap probes starting with v3. Earlier 1630 versions added too much startup cost. */ 1631 #if defined (HAVE_SYS_SDT_H) && defined (STAP_PROBE2) && _SDT_NOTE_TYPE >= 3 1632 STAP_PROBE2 (libgcc, unwind, cfa, handler); 1633 #else 1634 asm (""); 1635 #endif 1636 } 1637 1638 /* Frob exception handler's address kept in TARGET before installing into 1639 CURRENT context. */ 1640 1641 static inline void * 1642 uw_frob_return_addr (struct _Unwind_Context *current 1643 __attribute__ ((__unused__)), 1644 struct _Unwind_Context *target) 1645 { 1646 void *ret_addr = __builtin_frob_return_addr (target->ra); 1647 #ifdef MD_POST_FROB_EH_HANDLER_ADDR 1648 ret_addr = MD_POST_FROB_EH_HANDLER_ADDR (current, target, ret_addr); 1649 #endif 1650 return ret_addr; 1651 } 1652 1653 /* Install TARGET into CURRENT so that we can return to it. This is a 1654 macro because __builtin_eh_return must be invoked in the context of 1655 our caller. FRAMES is a number of frames to be unwind. 1656 _Unwind_Frames_Extra is a macro to do additional work during unwinding 1657 if needed, for example shadow stack pointer adjustment for Intel CET 1658 technology. */ 1659 1660 #define uw_install_context(CURRENT, TARGET, FRAMES) \ 1661 do \ 1662 { \ 1663 long offset = uw_install_context_1 ((CURRENT), (TARGET)); \ 1664 void *handler = uw_frob_return_addr ((CURRENT), (TARGET)); \ 1665 _Unwind_DebugHook ((TARGET)->cfa, handler); \ 1666 _Unwind_Frames_Extra (FRAMES); \ 1667 __builtin_eh_return (offset, handler); \ 1668 } \ 1669 while (0) 1670 1671 static long 1672 uw_install_context_1 (struct _Unwind_Context *current, 1673 struct _Unwind_Context *target) 1674 { 1675 long i; 1676 _Unwind_SpTmp sp_slot; 1677 1678 /* If the target frame does not have a saved stack pointer, 1679 then set up the target's CFA. */ 1680 if (!_Unwind_GetGRPtr (target, __builtin_dwarf_sp_column ())) 1681 _Unwind_SetSpColumn (target, target->cfa, &sp_slot); 1682 1683 for (i = 0; i < __LIBGCC_DWARF_FRAME_REGISTERS__; ++i) 1684 { 1685 void *c = (void *) (_Unwind_Internal_Ptr) current->reg[i]; 1686 void *t = (void *) (_Unwind_Internal_Ptr)target->reg[i]; 1687 1688 gcc_assert (current->by_value[i] == 0); 1689 if (target->by_value[i] && c) 1690 { 1691 _Unwind_Word w; 1692 _Unwind_Ptr p; 1693 if (dwarf_reg_size_table[i] == sizeof (_Unwind_Word)) 1694 { 1695 w = (_Unwind_Internal_Ptr) t; 1696 memcpy (c, &w, sizeof (_Unwind_Word)); 1697 } 1698 else 1699 { 1700 gcc_assert (dwarf_reg_size_table[i] == sizeof (_Unwind_Ptr)); 1701 p = (_Unwind_Internal_Ptr) t; 1702 memcpy (c, &p, sizeof (_Unwind_Ptr)); 1703 } 1704 } 1705 else if (t && c && t != c) 1706 memcpy (c, t, dwarf_reg_size_table[i]); 1707 } 1708 1709 /* If the current frame doesn't have a saved stack pointer, then we 1710 need to rely on EH_RETURN_STACKADJ_RTX to get our target stack 1711 pointer value reloaded. */ 1712 if (!_Unwind_GetGRPtr (current, __builtin_dwarf_sp_column ())) 1713 { 1714 void *target_cfa; 1715 1716 target_cfa = _Unwind_GetPtr (target, __builtin_dwarf_sp_column ()); 1717 1718 /* We adjust SP by the difference between CURRENT and TARGET's CFA. */ 1719 if (__LIBGCC_STACK_GROWS_DOWNWARD__) 1720 return target_cfa - current->cfa + target->args_size; 1721 else 1722 return current->cfa - target_cfa - target->args_size; 1723 } 1724 return 0; 1725 } 1726 1727 static inline _Unwind_Ptr 1728 uw_identify_context (struct _Unwind_Context *context) 1729 { 1730 /* The CFA is not sufficient to disambiguate the context of a function 1731 interrupted by a signal before establishing its frame and the context 1732 of the signal itself. */ 1733 if (__LIBGCC_STACK_GROWS_DOWNWARD__) 1734 return _Unwind_GetCFA (context) - _Unwind_IsSignalFrame (context); 1735 else 1736 return _Unwind_GetCFA (context) + _Unwind_IsSignalFrame (context); 1737 } 1738 1739 1740 #include "unwind.inc" 1741 1742 #if defined (USE_GAS_SYMVER) && defined (SHARED) && defined (USE_LIBUNWIND_EXCEPTIONS) 1743 alias (_Unwind_Backtrace); 1744 alias (_Unwind_DeleteException); 1745 alias (_Unwind_FindEnclosingFunction); 1746 alias (_Unwind_ForcedUnwind); 1747 alias (_Unwind_GetDataRelBase); 1748 alias (_Unwind_GetTextRelBase); 1749 alias (_Unwind_GetCFA); 1750 alias (_Unwind_GetGR); 1751 alias (_Unwind_GetIP); 1752 alias (_Unwind_GetLanguageSpecificData); 1753 alias (_Unwind_GetRegionStart); 1754 alias (_Unwind_RaiseException); 1755 alias (_Unwind_Resume); 1756 alias (_Unwind_Resume_or_Rethrow); 1757 alias (_Unwind_SetGR); 1758 alias (_Unwind_SetIP); 1759 #endif 1760 1761 #endif /* !USING_SJLJ_EXCEPTIONS */ 1762