1 //===------------------------- UnwindLevel1.c -----------------------------===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is dual licensed under the MIT and the University of Illinois Open 6 // Source Licenses. See LICENSE.TXT for details. 7 // 8 // 9 // Implements C++ ABI Exception Handling Level 1 as documented at: 10 // http://mentorembedded.github.io/cxx-abi/abi-eh.html 11 // using libunwind 12 // 13 //===----------------------------------------------------------------------===// 14 15 // ARM EHABI does not specify _Unwind_{Get,Set}{GR,IP}(). Thus, we are 16 // defining inline functions to delegate the function calls to 17 // _Unwind_VRS_{Get,Set}(). However, some applications might declare the 18 // function protetype directly (instead of including <unwind.h>), thus we need 19 // to export these functions from libunwind.so as well. 20 #define _LIBUNWIND_UNWIND_LEVEL1_EXTERNAL_LINKAGE 1 21 22 #include <inttypes.h> 23 #include <stdint.h> 24 #include <stdbool.h> 25 #include <stdlib.h> 26 #include <stdio.h> 27 #include <string.h> 28 29 #include "libunwind.h" 30 #include "unwind.h" 31 #include "config.h" 32 33 #if !defined(_LIBUNWIND_ARM_EHABI) && !defined(__USING_SJLJ_EXCEPTIONS__) 34 35 #ifndef _LIBUNWIND_SUPPORT_SEH_UNWIND 36 37 static _Unwind_Reason_Code 38 unwind_phase1(unw_context_t *uc, unw_cursor_t *cursor, _Unwind_Exception *exception_object) { 39 unw_init_local(cursor, uc); 40 41 // Walk each frame looking for a place to stop. 42 bool handlerNotFound = true; 43 while (handlerNotFound) { 44 // Ask libunwind to get next frame (skip over first which is 45 // _Unwind_RaiseException). 46 int stepResult = unw_step(cursor); 47 if (stepResult == 0) { 48 _LIBUNWIND_TRACE_UNWINDING("unwind_phase1(ex_ojb=%p): unw_step() reached " 49 "bottom => _URC_END_OF_STACK", 50 (void *)exception_object); 51 return _URC_END_OF_STACK; 52 } else if (stepResult < 0) { 53 _LIBUNWIND_TRACE_UNWINDING("unwind_phase1(ex_ojb=%p): unw_step failed => " 54 "_URC_FATAL_PHASE1_ERROR", 55 (void *)exception_object); 56 return _URC_FATAL_PHASE1_ERROR; 57 } 58 59 // See if frame has code to run (has personality routine). 60 unw_proc_info_t frameInfo; 61 unw_word_t sp; 62 if (unw_get_proc_info(cursor, &frameInfo) != UNW_ESUCCESS) { 63 _LIBUNWIND_TRACE_UNWINDING("unwind_phase1(ex_ojb=%p): unw_get_proc_info " 64 "failed => _URC_FATAL_PHASE1_ERROR", 65 (void *)exception_object); 66 return _URC_FATAL_PHASE1_ERROR; 67 } 68 69 // When tracing, print state information. 70 if (_LIBUNWIND_TRACING_UNWINDING) { 71 char functionBuf[512]; 72 const char *functionName = functionBuf; 73 unw_word_t offset; 74 if ((unw_get_proc_name(cursor, functionBuf, sizeof(functionBuf), 75 &offset) != UNW_ESUCCESS) || 76 (frameInfo.start_ip + offset > frameInfo.end_ip)) 77 functionName = ".anonymous."; 78 unw_word_t pc; 79 unw_get_reg(cursor, UNW_REG_IP, &pc); 80 _LIBUNWIND_TRACE_UNWINDING( 81 "unwind_phase1(ex_ojb=%p): pc=0x%" PRIxPTR ", start_ip=0x%" PRIxPTR 82 ", func=%s, lsda=0x%" PRIxPTR ", personality=0x%" PRIxPTR "", 83 (void *)exception_object, pc, frameInfo.start_ip, functionName, 84 frameInfo.lsda, frameInfo.handler); 85 } 86 87 // If there is a personality routine, ask it if it will want to stop at 88 // this frame. 89 if (frameInfo.handler != 0) { 90 __personality_routine p = 91 (__personality_routine)(uintptr_t)(frameInfo.handler); 92 _LIBUNWIND_TRACE_UNWINDING( 93 "unwind_phase1(ex_ojb=%p): calling personality function %p", 94 (void *)exception_object, (void *)(uintptr_t)p); 95 _Unwind_Reason_Code personalityResult = 96 (*p)(1, _UA_SEARCH_PHASE, exception_object->exception_class, 97 exception_object, (struct _Unwind_Context *)(cursor)); 98 switch (personalityResult) { 99 case _URC_HANDLER_FOUND: 100 // found a catch clause or locals that need destructing in this frame 101 // stop search and remember stack pointer at the frame 102 handlerNotFound = false; 103 unw_get_reg(cursor, UNW_REG_SP, &sp); 104 exception_object->private_2 = (uintptr_t)sp; 105 _LIBUNWIND_TRACE_UNWINDING( 106 "unwind_phase1(ex_ojb=%p): _URC_HANDLER_FOUND", 107 (void *)exception_object); 108 return _URC_NO_REASON; 109 110 case _URC_CONTINUE_UNWIND: 111 _LIBUNWIND_TRACE_UNWINDING( 112 "unwind_phase1(ex_ojb=%p): _URC_CONTINUE_UNWIND", 113 (void *)exception_object); 114 // continue unwinding 115 break; 116 117 default: 118 // something went wrong 119 _LIBUNWIND_TRACE_UNWINDING( 120 "unwind_phase1(ex_ojb=%p): _URC_FATAL_PHASE1_ERROR", 121 (void *)exception_object); 122 return _URC_FATAL_PHASE1_ERROR; 123 } 124 } 125 } 126 return _URC_NO_REASON; 127 } 128 129 130 static _Unwind_Reason_Code 131 unwind_phase2(unw_context_t *uc, unw_cursor_t *cursor, _Unwind_Exception *exception_object) { 132 unw_init_local(cursor, uc); 133 134 _LIBUNWIND_TRACE_UNWINDING("unwind_phase2(ex_ojb=%p)", 135 (void *)exception_object); 136 137 // Walk each frame until we reach where search phase said to stop. 138 while (true) { 139 140 // Ask libunwind to get next frame (skip over first which is 141 // _Unwind_RaiseException). 142 int stepResult = unw_step(cursor); 143 if (stepResult == 0) { 144 _LIBUNWIND_TRACE_UNWINDING("unwind_phase2(ex_ojb=%p): unw_step() reached " 145 "bottom => _URC_END_OF_STACK", 146 (void *)exception_object); 147 return _URC_END_OF_STACK; 148 } else if (stepResult < 0) { 149 _LIBUNWIND_TRACE_UNWINDING("unwind_phase2(ex_ojb=%p): unw_step failed => " 150 "_URC_FATAL_PHASE1_ERROR", 151 (void *)exception_object); 152 return _URC_FATAL_PHASE2_ERROR; 153 } 154 155 // Get info about this frame. 156 unw_word_t sp; 157 unw_proc_info_t frameInfo; 158 unw_get_reg(cursor, UNW_REG_SP, &sp); 159 if (unw_get_proc_info(cursor, &frameInfo) != UNW_ESUCCESS) { 160 _LIBUNWIND_TRACE_UNWINDING("unwind_phase2(ex_ojb=%p): unw_get_proc_info " 161 "failed => _URC_FATAL_PHASE1_ERROR", 162 (void *)exception_object); 163 return _URC_FATAL_PHASE2_ERROR; 164 } 165 166 // When tracing, print state information. 167 if (_LIBUNWIND_TRACING_UNWINDING) { 168 char functionBuf[512]; 169 const char *functionName = functionBuf; 170 unw_word_t offset; 171 if ((unw_get_proc_name(cursor, functionBuf, sizeof(functionBuf), 172 &offset) != UNW_ESUCCESS) || 173 (frameInfo.start_ip + offset > frameInfo.end_ip)) 174 functionName = ".anonymous."; 175 _LIBUNWIND_TRACE_UNWINDING("unwind_phase2(ex_ojb=%p): start_ip=0x%" PRIxPTR 176 ", func=%s, sp=0x%" PRIxPTR ", lsda=0x%" PRIxPTR 177 ", personality=0x%" PRIxPTR, 178 (void *)exception_object, frameInfo.start_ip, 179 functionName, sp, frameInfo.lsda, 180 frameInfo.handler); 181 } 182 183 // If there is a personality routine, tell it we are unwinding. 184 if (frameInfo.handler != 0) { 185 __personality_routine p = 186 (__personality_routine)(uintptr_t)(frameInfo.handler); 187 _Unwind_Action action = _UA_CLEANUP_PHASE; 188 if (sp == exception_object->private_2) { 189 // Tell personality this was the frame it marked in phase 1. 190 action = (_Unwind_Action)(_UA_CLEANUP_PHASE | _UA_HANDLER_FRAME); 191 } 192 _Unwind_Reason_Code personalityResult = 193 (*p)(1, action, exception_object->exception_class, exception_object, 194 (struct _Unwind_Context *)(cursor)); 195 switch (personalityResult) { 196 case _URC_CONTINUE_UNWIND: 197 // Continue unwinding 198 _LIBUNWIND_TRACE_UNWINDING( 199 "unwind_phase2(ex_ojb=%p): _URC_CONTINUE_UNWIND", 200 (void *)exception_object); 201 if (sp == exception_object->private_2) { 202 // Phase 1 said we would stop at this frame, but we did not... 203 _LIBUNWIND_ABORT("during phase1 personality function said it would " 204 "stop here, but now in phase2 it did not stop here"); 205 } 206 break; 207 case _URC_INSTALL_CONTEXT: 208 _LIBUNWIND_TRACE_UNWINDING( 209 "unwind_phase2(ex_ojb=%p): _URC_INSTALL_CONTEXT", 210 (void *)exception_object); 211 // Personality routine says to transfer control to landing pad. 212 // We may get control back if landing pad calls _Unwind_Resume(). 213 if (_LIBUNWIND_TRACING_UNWINDING) { 214 unw_word_t pc; 215 unw_get_reg(cursor, UNW_REG_IP, &pc); 216 unw_get_reg(cursor, UNW_REG_SP, &sp); 217 _LIBUNWIND_TRACE_UNWINDING("unwind_phase2(ex_ojb=%p): re-entering " 218 "user code with ip=0x%" PRIxPTR 219 ", sp=0x%" PRIxPTR, 220 (void *)exception_object, pc, sp); 221 } 222 unw_resume(cursor); 223 // unw_resume() only returns if there was an error. 224 return _URC_FATAL_PHASE2_ERROR; 225 default: 226 // Personality routine returned an unknown result code. 227 _LIBUNWIND_DEBUG_LOG("personality function returned unknown result %d", 228 personalityResult); 229 return _URC_FATAL_PHASE2_ERROR; 230 } 231 } 232 } 233 234 // Clean up phase did not resume at the frame that the search phase 235 // said it would... 236 return _URC_FATAL_PHASE2_ERROR; 237 } 238 239 static _Unwind_Reason_Code 240 unwind_phase2_forced(unw_context_t *uc, unw_cursor_t *cursor, 241 _Unwind_Exception *exception_object, 242 _Unwind_Stop_Fn stop, void *stop_parameter) { 243 unw_init_local(cursor, uc); 244 245 // Walk each frame until we reach where search phase said to stop 246 while (unw_step(cursor) > 0) { 247 248 // Update info about this frame. 249 unw_proc_info_t frameInfo; 250 if (unw_get_proc_info(cursor, &frameInfo) != UNW_ESUCCESS) { 251 _LIBUNWIND_TRACE_UNWINDING("unwind_phase2_forced(ex_ojb=%p): unw_step " 252 "failed => _URC_END_OF_STACK", 253 (void *)exception_object); 254 return _URC_FATAL_PHASE2_ERROR; 255 } 256 257 // When tracing, print state information. 258 if (_LIBUNWIND_TRACING_UNWINDING) { 259 char functionBuf[512]; 260 const char *functionName = functionBuf; 261 unw_word_t offset; 262 if ((unw_get_proc_name(cursor, functionBuf, sizeof(functionBuf), 263 &offset) != UNW_ESUCCESS) || 264 (frameInfo.start_ip + offset > frameInfo.end_ip)) 265 functionName = ".anonymous."; 266 _LIBUNWIND_TRACE_UNWINDING( 267 "unwind_phase2_forced(ex_ojb=%p): start_ip=0x%" PRIxPTR 268 ", func=%s, lsda=0x%" PRIxPTR ", personality=0x%" PRIxPTR, 269 (void *)exception_object, frameInfo.start_ip, functionName, 270 frameInfo.lsda, frameInfo.handler); 271 } 272 273 // Call stop function at each frame. 274 _Unwind_Action action = 275 (_Unwind_Action)(_UA_FORCE_UNWIND | _UA_CLEANUP_PHASE); 276 _Unwind_Reason_Code stopResult = 277 (*stop)(1, action, exception_object->exception_class, exception_object, 278 (struct _Unwind_Context *)(cursor), stop_parameter); 279 _LIBUNWIND_TRACE_UNWINDING( 280 "unwind_phase2_forced(ex_ojb=%p): stop function returned %d", 281 (void *)exception_object, stopResult); 282 if (stopResult != _URC_NO_REASON) { 283 _LIBUNWIND_TRACE_UNWINDING( 284 "unwind_phase2_forced(ex_ojb=%p): stopped by stop function", 285 (void *)exception_object); 286 return _URC_FATAL_PHASE2_ERROR; 287 } 288 289 // If there is a personality routine, tell it we are unwinding. 290 if (frameInfo.handler != 0) { 291 __personality_routine p = 292 (__personality_routine)(intptr_t)(frameInfo.handler); 293 _LIBUNWIND_TRACE_UNWINDING( 294 "unwind_phase2_forced(ex_ojb=%p): calling personality function %p", 295 (void *)exception_object, (void *)(uintptr_t)p); 296 _Unwind_Reason_Code personalityResult = 297 (*p)(1, action, exception_object->exception_class, exception_object, 298 (struct _Unwind_Context *)(cursor)); 299 switch (personalityResult) { 300 case _URC_CONTINUE_UNWIND: 301 _LIBUNWIND_TRACE_UNWINDING("unwind_phase2_forced(ex_ojb=%p): " 302 "personality returned " 303 "_URC_CONTINUE_UNWIND", 304 (void *)exception_object); 305 // Destructors called, continue unwinding 306 break; 307 case _URC_INSTALL_CONTEXT: 308 _LIBUNWIND_TRACE_UNWINDING("unwind_phase2_forced(ex_ojb=%p): " 309 "personality returned " 310 "_URC_INSTALL_CONTEXT", 311 (void *)exception_object); 312 // We may get control back if landing pad calls _Unwind_Resume(). 313 unw_resume(cursor); 314 break; 315 default: 316 // Personality routine returned an unknown result code. 317 _LIBUNWIND_TRACE_UNWINDING("unwind_phase2_forced(ex_ojb=%p): " 318 "personality returned %d, " 319 "_URC_FATAL_PHASE2_ERROR", 320 (void *)exception_object, personalityResult); 321 return _URC_FATAL_PHASE2_ERROR; 322 } 323 } 324 } 325 326 // Call stop function one last time and tell it we've reached the end 327 // of the stack. 328 _LIBUNWIND_TRACE_UNWINDING("unwind_phase2_forced(ex_ojb=%p): calling stop " 329 "function with _UA_END_OF_STACK", 330 (void *)exception_object); 331 _Unwind_Action lastAction = 332 (_Unwind_Action)(_UA_FORCE_UNWIND | _UA_CLEANUP_PHASE | _UA_END_OF_STACK); 333 (*stop)(1, lastAction, exception_object->exception_class, exception_object, 334 (struct _Unwind_Context *)(cursor), stop_parameter); 335 336 // Clean up phase did not resume at the frame that the search phase said it 337 // would. 338 return _URC_FATAL_PHASE2_ERROR; 339 } 340 341 342 /// Called by __cxa_throw. Only returns if there is a fatal error. 343 _LIBUNWIND_EXPORT _Unwind_Reason_Code 344 _Unwind_RaiseException(_Unwind_Exception *exception_object) { 345 _LIBUNWIND_TRACE_API("_Unwind_RaiseException(ex_obj=%p)", 346 (void *)exception_object); 347 unw_context_t uc; 348 unw_cursor_t cursor; 349 unw_getcontext(&uc); 350 351 // Mark that this is a non-forced unwind, so _Unwind_Resume() 352 // can do the right thing. 353 exception_object->private_1 = 0; 354 exception_object->private_2 = 0; 355 356 // phase 1: the search phase 357 _Unwind_Reason_Code phase1 = unwind_phase1(&uc, &cursor, exception_object); 358 if (phase1 != _URC_NO_REASON) 359 return phase1; 360 361 // phase 2: the clean up phase 362 return unwind_phase2(&uc, &cursor, exception_object); 363 } 364 365 366 367 /// When _Unwind_RaiseException() is in phase2, it hands control 368 /// to the personality function at each frame. The personality 369 /// may force a jump to a landing pad in that function, the landing 370 /// pad code may then call _Unwind_Resume() to continue with the 371 /// unwinding. Note: the call to _Unwind_Resume() is from compiler 372 /// geneated user code. All other _Unwind_* routines are called 373 /// by the C++ runtime __cxa_* routines. 374 /// 375 /// Note: re-throwing an exception (as opposed to continuing the unwind) 376 /// is implemented by having the code call __cxa_rethrow() which 377 /// in turn calls _Unwind_Resume_or_Rethrow(). 378 _LIBUNWIND_EXPORT void 379 _Unwind_Resume(_Unwind_Exception *exception_object) { 380 _LIBUNWIND_TRACE_API("_Unwind_Resume(ex_obj=%p)", (void *)exception_object); 381 unw_context_t uc; 382 unw_cursor_t cursor; 383 unw_getcontext(&uc); 384 385 if (exception_object->private_1 != 0) 386 unwind_phase2_forced(&uc, &cursor, exception_object, 387 (_Unwind_Stop_Fn) exception_object->private_1, 388 (void *)exception_object->private_2); 389 else 390 unwind_phase2(&uc, &cursor, exception_object); 391 392 // Clients assume _Unwind_Resume() does not return, so all we can do is abort. 393 _LIBUNWIND_ABORT("_Unwind_Resume() can't return"); 394 } 395 396 397 398 /// Not used by C++. 399 /// Unwinds stack, calling "stop" function at each frame. 400 /// Could be used to implement longjmp(). 401 _LIBUNWIND_EXPORT _Unwind_Reason_Code 402 _Unwind_ForcedUnwind(_Unwind_Exception *exception_object, 403 _Unwind_Stop_Fn stop, void *stop_parameter) { 404 _LIBUNWIND_TRACE_API("_Unwind_ForcedUnwind(ex_obj=%p, stop=%p)", 405 (void *)exception_object, (void *)(uintptr_t)stop); 406 unw_context_t uc; 407 unw_cursor_t cursor; 408 unw_getcontext(&uc); 409 410 // Mark that this is a forced unwind, so _Unwind_Resume() can do 411 // the right thing. 412 exception_object->private_1 = (uintptr_t) stop; 413 exception_object->private_2 = (uintptr_t) stop_parameter; 414 415 // do it 416 return unwind_phase2_forced(&uc, &cursor, exception_object, stop, stop_parameter); 417 } 418 419 420 /// Called by personality handler during phase 2 to get LSDA for current frame. 421 _LIBUNWIND_EXPORT uintptr_t 422 _Unwind_GetLanguageSpecificData(struct _Unwind_Context *context) { 423 unw_cursor_t *cursor = (unw_cursor_t *)context; 424 unw_proc_info_t frameInfo; 425 uintptr_t result = 0; 426 if (unw_get_proc_info(cursor, &frameInfo) == UNW_ESUCCESS) 427 result = (uintptr_t)frameInfo.lsda; 428 _LIBUNWIND_TRACE_API( 429 "_Unwind_GetLanguageSpecificData(context=%p) => 0x%" PRIxPTR, 430 (void *)context, result); 431 if (result != 0) { 432 if (*((uint8_t *)result) != 0xFF) 433 _LIBUNWIND_DEBUG_LOG("lsda at 0x%" PRIxPTR " does not start with 0xFF", 434 result); 435 } 436 return result; 437 } 438 439 440 /// Called by personality handler during phase 2 to find the start of the 441 /// function. 442 _LIBUNWIND_EXPORT uintptr_t 443 _Unwind_GetRegionStart(struct _Unwind_Context *context) { 444 unw_cursor_t *cursor = (unw_cursor_t *)context; 445 unw_proc_info_t frameInfo; 446 uintptr_t result = 0; 447 if (unw_get_proc_info(cursor, &frameInfo) == UNW_ESUCCESS) 448 result = (uintptr_t)frameInfo.start_ip; 449 _LIBUNWIND_TRACE_API("_Unwind_GetRegionStart(context=%p) => 0x%" PRIxPTR, 450 (void *)context, result); 451 return result; 452 } 453 454 #endif // !_LIBUNWIND_SUPPORT_SEH_UNWIND 455 456 /// Called by personality handler during phase 2 if a foreign exception 457 // is caught. 458 _LIBUNWIND_EXPORT void 459 _Unwind_DeleteException(_Unwind_Exception *exception_object) { 460 _LIBUNWIND_TRACE_API("_Unwind_DeleteException(ex_obj=%p)", 461 (void *)exception_object); 462 if (exception_object->exception_cleanup != NULL) 463 (*exception_object->exception_cleanup)(_URC_FOREIGN_EXCEPTION_CAUGHT, 464 exception_object); 465 } 466 467 /// Called by personality handler during phase 2 to get register values. 468 _LIBUNWIND_EXPORT uintptr_t 469 _Unwind_GetGR(struct _Unwind_Context *context, int index) { 470 unw_cursor_t *cursor = (unw_cursor_t *)context; 471 unw_word_t result; 472 unw_get_reg(cursor, index, &result); 473 _LIBUNWIND_TRACE_API("_Unwind_GetGR(context=%p, reg=%d) => 0x%" PRIxPTR, 474 (void *)context, index, result); 475 return (uintptr_t)result; 476 } 477 478 /// Called by personality handler during phase 2 to alter register values. 479 _LIBUNWIND_EXPORT void _Unwind_SetGR(struct _Unwind_Context *context, int index, 480 uintptr_t value) { 481 _LIBUNWIND_TRACE_API("_Unwind_SetGR(context=%p, reg=%d, value=0x%0" PRIxPTR 482 ")", 483 (void *)context, index, value); 484 unw_cursor_t *cursor = (unw_cursor_t *)context; 485 unw_set_reg(cursor, index, value); 486 } 487 488 /// Called by personality handler during phase 2 to get instruction pointer. 489 _LIBUNWIND_EXPORT uintptr_t _Unwind_GetIP(struct _Unwind_Context *context) { 490 unw_cursor_t *cursor = (unw_cursor_t *)context; 491 unw_word_t result; 492 unw_get_reg(cursor, UNW_REG_IP, &result); 493 _LIBUNWIND_TRACE_API("_Unwind_GetIP(context=%p) => 0x%" PRIxPTR, 494 (void *)context, result); 495 return (uintptr_t)result; 496 } 497 498 /// Called by personality handler during phase 2 to alter instruction pointer, 499 /// such as setting where the landing pad is, so _Unwind_Resume() will 500 /// start executing in the landing pad. 501 _LIBUNWIND_EXPORT void _Unwind_SetIP(struct _Unwind_Context *context, 502 uintptr_t value) { 503 _LIBUNWIND_TRACE_API("_Unwind_SetIP(context=%p, value=0x%0" PRIxPTR ")", 504 (void *)context, value); 505 unw_cursor_t *cursor = (unw_cursor_t *)context; 506 unw_set_reg(cursor, UNW_REG_IP, value); 507 } 508 509 #endif // !defined(_LIBUNWIND_ARM_EHABI) && !defined(__USING_SJLJ_EXCEPTIONS__) 510