//===------------------------- UnwindLevel1.c -----------------------------===//

//

//                     The LLVM Compiler Infrastructure

//

// This file is dual licensed under the MIT and the University of Illinois Open

// Source Licenses. See LICENSE.TXT for details.

//

//

// Implements C++ ABI Exception Handling Level 1 as documented at:

//      http://mentorembedded.github.io/cxx-abi/abi-eh.html

// using libunwind

//

//===----------------------------------------------------------------------===//

// ARM EHABI does not specify _Unwind_{Get,Set}{GR,IP}().  Thus, we are

// defining inline functions to delegate the function calls to

// _Unwind_VRS_{Get,Set}().  However, some applications might declare the

// function protetype directly (instead of including <unwind.h>), thus we need

// to export these functions from libunwind.so as well.

#define _LIBUNWIND_UNWIND_LEVEL1_EXTERNAL_LINKAGE 1

#include <inttypes.h>

#include <stdint.h>

#include <stdbool.h>

#include <stdlib.h>

#include <stdio.h>

#include <string.h>

#include "libunwind.h"

#include "unwind.h"

#include "config.h"

#if !_LIBUNWIND_ARM_EHABI

static _Unwind_Reason_Code

unwind_phase1(unw_context_t *uc, unw_cursor_t *cursor, _Unwind_Exception *exception_object) {

  // Walk each frame looking for a place to stop.

  bool handlerNotFound = true;

    // Ask libuwind to get next frame (skip over first which is

    // _Unwind_RaiseException).

                                 "bottom => _URC_END_OF_STACK\n",

                                 (void *)exception_object);

                                 "_URC_FATAL_PHASE1_ERROR\n",

                                 (void *)exception_object);

    }

    // See if frame has code to run (has personality routine).

                                 "failed => _URC_FATAL_PHASE1_ERROR\n",

                                 (void *)exception_object);

    }

    // When tracing, print state information.

          "unwind_phase1(ex_ojb=%p): pc=0x%" PRIx64 ", start_ip=0x%" PRIx64

          ", func=%s, lsda=0x%" PRIx64 ", personality=0x%" PRIx64 "\n",

          (void *)exception_object, pc, frameInfo.start_ip, functionName,

          frameInfo.lsda, frameInfo.handler);

    }

    // If there is a personality routine, ask it if it will want to stop at

    // this frame.

      __personality_routine p =

          "unwind_phase1(ex_ojb=%p): calling personality function %p\n",

          (void *)exception_object, (void *)(uintptr_t)p);

      _Unwind_Reason_Code personalityResult =

      case _URC_HANDLER_FOUND:

        // found a catch clause or locals that need destructing in this frame

        // stop search and remember stack pointer at the frame

        handlerNotFound = false;

            "unwind_phase1(ex_ojb=%p): _URC_HANDLER_FOUND \n",

            (void *)exception_object);

      case _URC_CONTINUE_UNWIND:

            "unwind_phase1(ex_ojb=%p): _URC_CONTINUE_UNWIND\n",

            (void *)exception_object);

        // continue unwinding

        break;

      default:

        // something went wrong

            "unwind_phase1(ex_ojb=%p): _URC_FATAL_PHASE1_ERROR\n",

            (void *)exception_object);

      }

    }

static _Unwind_Reason_Code

unwind_phase2(unw_context_t *uc, unw_cursor_t *cursor, _Unwind_Exception *exception_object) {

                             (void *)exception_object);

  // Walk each frame until we reach where search phase said to stop.

  while (true) {

    // Ask libuwind to get next frame (skip over first which is

    // _Unwind_RaiseException).

                                 "bottom => _URC_END_OF_STACK\n",

                                 (void *)exception_object);

                                 "_URC_FATAL_PHASE1_ERROR\n",

                                 (void *)exception_object);

    }

    // Get info about this frame.

                                 "failed => _URC_FATAL_PHASE1_ERROR\n",

                                 (void *)exception_object);

    }

    // When tracing, print state information.

                                 ", func=%s, sp=0x%" PRIx64 ", lsda=0x%" PRIx64

                                 ", personality=0x%" PRIx64 "\n",

                                 (void *)exception_object, frameInfo.start_ip,

                                 functionName, sp, frameInfo.lsda,

                                 frameInfo.handler);

    }

    // If there is a personality routine, tell it we are unwinding.

      __personality_routine p =

      _Unwind_Action action = _UA_CLEANUP_PHASE;

        // Tell personality this was the frame it marked in phase 1.

        action = (_Unwind_Action)(_UA_CLEANUP_PHASE | _UA_HANDLER_FRAME);

      }

       _Unwind_Reason_Code personalityResult =

      case _URC_CONTINUE_UNWIND:

        // Continue unwinding

            "unwind_phase2(ex_ojb=%p): _URC_CONTINUE_UNWIND\n",

            (void *)exception_object);

          // Phase 1 said we would stop at this frame, but we did not...

                           "stop here, but now in phase2 it did not stop here");

        }

        break;

      case _URC_INSTALL_CONTEXT:

            "unwind_phase2(ex_ojb=%p): _URC_INSTALL_CONTEXT\n",

            (void *)exception_object);

        // Personality routine says to transfer control to landing pad.

        // We may get control back if landing pad calls _Unwind_Resume().

                                     "user code with ip=0x%" PRIx64

                                     ", sp=0x%" PRIx64 "\n",

                                     (void *)exception_object, pc, sp);

        }

        // unw_resume() only returns if there was an error.

      default:

        // Personality routine returned an unknown result code.

                             personalityResult);

      }

    }

  // Clean up phase did not resume at the frame that the search phase

  // said it would...

  return _URC_FATAL_PHASE2_ERROR;

}

static _Unwind_Reason_Code

unwind_phase2_forced(unw_context_t *uc, unw_cursor_t *cursor,

                     _Unwind_Exception *exception_object,

                     _Unwind_Stop_Fn stop, void *stop_parameter) {

  // Walk each frame until we reach where search phase said to stop

    // Update info about this frame.

                                 "failed => _URC_END_OF_STACK\n",

                                 (void *)exception_object);

    }

    // When tracing, print state information.

          "unwind_phase2_forced(ex_ojb=%p): start_ip=0x%" PRIx64

          ", func=%s, lsda=0x%" PRIx64 ", personality=0x%" PRIx64 "\n",

          (void *)exception_object, frameInfo.start_ip, functionName,

          frameInfo.lsda, frameInfo.handler);

    }

    // Call stop function at each frame.

    _Unwind_Action action =

        (_Unwind_Action)(_UA_FORCE_UNWIND | _UA_CLEANUP_PHASE);

    _Unwind_Reason_Code stopResult =

        "unwind_phase2_forced(ex_ojb=%p): stop function returned %d\n",

        (void *)exception_object, stopResult);

          "unwind_phase2_forced(ex_ojb=%p): stopped by stop function\n",

          (void *)exception_object);

    }

    // If there is a personality routine, tell it we are unwinding.

      __personality_routine p =

          "unwind_phase2_forced(ex_ojb=%p): calling personality function %p\n",

          (void *)exception_object, (void *)(uintptr_t)p);

      _Unwind_Reason_Code personalityResult =

               (struct _Unwind_Context *)(cursor));

      case _URC_CONTINUE_UNWIND:

                                   "personality returned "

                                   "_URC_CONTINUE_UNWIND\n",

                                   (void *)exception_object);

        // Destructors called, continue unwinding

        break;

      case _URC_INSTALL_CONTEXT:

                                   "personality returned "

                                   "_URC_INSTALL_CONTEXT\n",

                                   (void *)exception_object);

        // We may get control back if landing pad calls _Unwind_Resume().

      default:

        // Personality routine returned an unknown result code.

                                   "personality returned %d, "

                                   "_URC_FATAL_PHASE2_ERROR\n",

                                   (void *)exception_object, personalityResult);

      }

    }

  }

  // Call stop function one last time and tell it we've reached the end

  // of the stack.

                             "function with _UA_END_OF_STACK\n",

                             (void *)exception_object);

  _Unwind_Action lastAction =

      (_Unwind_Action)(_UA_FORCE_UNWIND | _UA_CLEANUP_PHASE | _UA_END_OF_STACK);

  // Clean up phase did not resume at the frame that the search phase said it

  // would.

  return _URC_FATAL_PHASE2_ERROR;

}

/// Called by __cxa_throw.  Only returns if there is a fatal error.

_LIBUNWIND_EXPORT _Unwind_Reason_Code

_Unwind_RaiseException(_Unwind_Exception *exception_object) {

                       (void *)exception_object);

  // Mark that this is a non-forced unwind, so _Unwind_Resume()

  // can do the right thing.

  // phase 1: the search phase

  // phase 2: the clean up phase

}

/// When _Unwind_RaiseException() is in phase2, it hands control

/// to the personality function at each frame.  The personality

/// may force a jump to a landing pad in that function, the landing

/// pad code may then call _Unwind_Resume() to continue with the

/// unwinding.  Note: the call to _Unwind_Resume() is from compiler

/// geneated user code.  All other _Unwind_* routines are called

/// by the C++ runtime __cxa_* routines.

///

/// Note: re-throwing an exception (as opposed to continuing the unwind)

/// is implemented by having the code call __cxa_rethrow() which

/// in turn calls _Unwind_Resume_or_Rethrow().

_LIBUNWIND_EXPORT void

_Unwind_Resume(_Unwind_Exception *exception_object) {

  else

  // Clients assume _Unwind_Resume() does not return, so all we can do is abort.

}

/// Not used by C++.

/// Unwinds stack, calling "stop" function at each frame.

/// Could be used to implement longjmp().

_LIBUNWIND_EXPORT _Unwind_Reason_Code

_Unwind_ForcedUnwind(_Unwind_Exception *exception_object,

                     _Unwind_Stop_Fn stop, void *stop_parameter) {

                       (void *)exception_object, (void *)(uintptr_t)stop);

  // Mark that this is a forced unwind, so _Unwind_Resume() can do

  // the right thing.

  // do it

}

/// Called by personality handler during phase 2 to get LSDA for current frame.

_LIBUNWIND_EXPORT uintptr_t

_Unwind_GetLanguageSpecificData(struct _Unwind_Context *context) {

  uintptr_t result = 0;

      "_Unwind_GetLanguageSpecificData(context=%p) => 0x%" PRIxPTR "\n",

      (void *)context, result);

                           result);

  }

/// Called by personality handler during phase 2 to find the start of the

/// function.

_LIBUNWIND_EXPORT uintptr_t

_Unwind_GetRegionStart(struct _Unwind_Context *context) {

  uintptr_t result = 0;

                       (void *)context, result);

/// Called by personality handler during phase 2 if a foreign exception

// is caught.

_LIBUNWIND_EXPORT void

_Unwind_DeleteException(_Unwind_Exception *exception_object) {

                       (void *)exception_object);

                                           exception_object);

}

/// Called by personality handler during phase 2 to get register values.

_LIBUNWIND_EXPORT uintptr_t

_Unwind_GetGR(struct _Unwind_Context *context, int index) {

                       (void *)context, index, (uint64_t)result);

}

/// Called by personality handler during phase 2 to alter register values.

_LIBUNWIND_EXPORT void _Unwind_SetGR(struct _Unwind_Context *context, int index,

                                     uintptr_t value) {

                       ")\n",

                       (void *)context, index, (uint64_t)value);

/// Called by personality handler during phase 2 to get instruction pointer.

_LIBUNWIND_EXPORT uintptr_t _Unwind_GetIP(struct _Unwind_Context *context) {

                       (void *)context, (uint64_t)result);

/// Called by personality handler during phase 2 to alter instruction pointer,

/// such as setting where the landing pad is, so _Unwind_Resume() will

/// start executing in the landing pad.

_LIBUNWIND_EXPORT void _Unwind_SetIP(struct _Unwind_Context *context,

                                     uintptr_t value) {

                       (void *)context, (uint64_t)value);

#endif // !_LIBUNWIND_ARM_EHABI