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