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