//! 由 libgcc/libunwind 支持的 panics 的实现 (以某种形式)。
//!
//! 有关异常处理和栈的背景展开，请参见 "LLVM 中的异常处理" (llvm.org/docs/ExceptionHandling.html) 及其链接的文档。
//! 这些也是不错的读物：
//!  * <https://itanium-cxx-abi.github.io/cxx-abi/abi-eh.html>
//!  * <https://monoinfinito.wordpress.com/series/exception-handling-in-c/>
//!  * <https://www.airs.com/blog/index.php?s=exception+frames>
//!
//! ## 简要总结
//!
//! 异常处理分为两个阶段：搜索阶段和清理阶段。
//!
//! 在这两个阶段中，展开器都使用当前进程模块的栈框架 unwind 部分 (此处的 "module" 指 OS 模块，即可执行文件或动态库) 中的信息从上到下遍历栈框架。
//!
//!
//! 对于每个栈帧，它调用关联的 "personality routine"，其地址也存储在 unwind info 节中。
//!
//! 在搜索阶段，personality 例程的工作是检查抛出的异常对象，并确定是否应在该栈帧处捕获该异常对象。一旦确定了处理程序框架，清除阶段就会开始。
//!
//! 在清理阶段，展开器再次调用每个 personality 例程。
//! 这次，它决定需要为当前栈帧运行哪些 (如果有的话) 清除代码。如果是这样，则将控件转移到函数体中的特殊分支 "landing pad"，该分支调用析构函数，释放内存等。
//! 在着陆架的尽头，控制权被转移回展开器，并且展开恢复。
//!
//! 一旦将栈展开到处理程序框架级别，展开将停止，最后一个 personality 例程将控制权转移到 catch 块。
//!
//!
//!
//!
//!
//!
//!
//!
//!
//!
//!
//!
//!

use super::dwarf::eh::{self, EHAction, EHContext};
use crate::ffi::c_int;
use libc::uintptr_t;
use unwind as uw;

// 对于每种体系结构，从 LLVM 的 TargetLowering::getExceptionPointerRegister () 和 TargetLowering::getExceptionSelectorRegister () 提取寄存器 ID，然后通过寄存器定义表将其映射到 DWARF 寄存器号 (通常是) <arch>RegisterInfo.td，搜索 "DwarfRegNum")。
//
// 另请参见 https://llvm.org/docs/WritingAnLLVMBackend.html#defining-a-register。
//
//

#[cfg(target_arch = "x86")]
const UNWIND_DATA_REG: (i32, i32) = (0, 2); // EAX, EDX

#[cfg(target_arch = "x86_64")]
const UNWIND_DATA_REG: (i32, i32) = (0, 1); // RAX, RDX

#[cfg(any(target_arch = "arm", target_arch = "aarch64"))]
const UNWIND_DATA_REG: (i32, i32) = (0, 1); // R0, R1 / X0, X1

#[cfg(target_arch = "m68k")]
const UNWIND_DATA_REG: (i32, i32) = (0, 1); // D0, D1

#[cfg(any(target_arch = "mips", target_arch = "mips64"))]
const UNWIND_DATA_REG: (i32, i32) = (4, 5); // A0, A1

#[cfg(any(target_arch = "powerpc", target_arch = "powerpc64"))]
const UNWIND_DATA_REG: (i32, i32) = (3, 4); // R3, R4 / X3, X4

#[cfg(target_arch = "s390x")]
const UNWIND_DATA_REG: (i32, i32) = (6, 7); // R6, R7

#[cfg(any(target_arch = "sparc", target_arch = "sparc64"))]
const UNWIND_DATA_REG: (i32, i32) = (24, 25); // I0, I1

#[cfg(target_arch = "hexagon")]
const UNWIND_DATA_REG: (i32, i32) = (0, 1); // R0, R1

#[cfg(any(target_arch = "riscv64", target_arch = "riscv32"))]
const UNWIND_DATA_REG: (i32, i32) = (10, 11); // x10, x11

#[cfg(target_arch = "loongarch64")]
const UNWIND_DATA_REG: (i32, i32) = (4, 5); // a0, a1

// 以下代码基于 GCC 的 C 和 C++ 的 personality 例程。有关引用，请参见：
// https://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_personality.cc
// https://github.com/gcc-mirror/gcc/blob/trunk/libgcc/unwind-c.c

cfg_if::cfg_if! {
    if #[cfg(all(target_arch = "arm", not(target_os = "ios"), not(target_os = "watchos"), not(target_os = "netbsd")))] {
        // ARM EHABI 的 personality 例程。
        // https://infocenter.arm.com/help/topic/com.arm.doc.ihi0038b/IHI0038B_ehabi.pdf
        //
        // iOS 使用默认例程，因为它使用 SjLj 展开。
        #[lang = "eh_personality"]
        unsafe extern "C" fn rust_eh_personality(
            state: uw::_Unwind_State,
            exception_object: *mut uw::_Unwind_Exception,
            context: *mut uw::_Unwind_Context,
        ) -> uw::_Unwind_Reason_Code {
            let state = state as c_int;
            let action = state & uw::_US_ACTION_MASK as c_int;
            let search_phase = if action == uw::_US_VIRTUAL_UNWIND_FRAME as c_int {
                // ARM 上的回溯将调用具有 state == _US_VIRTUAL_UNWIND_FRAME | _US_FORCE_UNWIND 的 personality 例程。
                // 在那种情况下，我们想继续展开栈，否则我们所有的回溯都将以 __rust_try 结尾
                //
                //
                if state & uw::_US_FORCE_UNWIND as c_int != 0 {
                    return continue_unwind(exception_object, context);
                }
                true
            } else if action == uw::_US_UNWIND_FRAME_STARTING as c_int {
                false
            } else if action == uw::_US_UNWIND_FRAME_RESUME as c_int {
                return continue_unwind(exception_object, context);
            } else {
                return uw::_URC_FAILURE;
            };

            // DWARF 展开器假定 _Unwind_Context 包含函数和 LSDA 指针之类的内容，但是 ARM EHABI 将其放入异常对象中。
            // 为了保留仅使用上下文指针的 _Unwind_GetLanguageSpecificData() 之类的函数签名，GCC 的 personality 例程使用为 "暂存寄存器" (r12) 保留的位置在上下文中存储了指向 exception_object 的指针。
            //
            //
            //
            //
            uw::_Unwind_SetGR(context, uw::UNWIND_POINTER_REG, exception_object as uw::_Unwind_Ptr);
            // ...一种更有原则的方法是在我们的 libunwind 绑定中提供分支的 _Unwind_Context 的完整定义，并直接从那里获取所需的数据，绕过 DWARF 兼容性函数。
            //
            //

            let eh_action = match find_eh_action(context) {
                Ok(action) => action,
                Err(_) => return uw::_URC_FAILURE,
            };
            if search_phase {
                match eh_action {
                    EHAction::None | EHAction::Cleanup(_) => {
                        return continue_unwind(exception_object, context);
                    }
                    EHAction::Catch(_) | EHAction::Filter(_) => {
                        // EHABI 要求 personality 例程更新异常对象的屏障缓存中的 SP 值。
                        //
                        (*exception_object).private[5] =
                            uw::_Unwind_GetGR(context, uw::UNWIND_SP_REG);
                        return uw::_URC_HANDLER_FOUND;
                    }
                    EHAction::Terminate => return uw::_URC_FAILURE,
                }
            } else {
                match eh_action {
                    EHAction::None => return continue_unwind(exception_object, context),
                    EHAction::Filter(_) if state & uw::_US_FORCE_UNWIND as c_int != 0 => return continue_unwind(exception_object, context),
                    EHAction::Cleanup(lpad) | EHAction::Catch(lpad) | EHAction::Filter(lpad) => {
                        uw::_Unwind_SetGR(
                            context,
                            UNWIND_DATA_REG.0,
                            exception_object as uintptr_t,
                        );
                        uw::_Unwind_SetGR(context, UNWIND_DATA_REG.1, 0);
                        uw::_Unwind_SetIP(context, lpad);
                        return uw::_URC_INSTALL_CONTEXT;
                    }
                    EHAction::Terminate => return uw::_URC_FAILURE,
                }
            }

            // 在 ARM EHABI 上， personality 例程负责在返回之前实际展开单个栈帧 (ARM EHABI Sec。
            // 6.1).
            unsafe fn continue_unwind(
                exception_object: *mut uw::_Unwind_Exception,
                context: *mut uw::_Unwind_Context,
            ) -> uw::_Unwind_Reason_Code {
                if __gnu_unwind_frame(exception_object, context) == uw::_URC_NO_REASON {
                    uw::_URC_CONTINUE_UNWIND
                } else {
                    uw::_URC_FAILURE
                }
            }
            // 在 libgcc 中定义
            extern "C" {
                fn __gnu_unwind_frame(
                    exception_object: *mut uw::_Unwind_Exception,
                    context: *mut uw::_Unwind_Context,
                ) -> uw::_Unwind_Reason_Code;
            }
        }
    } else {
        // 默认 personality 例程，可直接在大多数目标上使用，并通过 SEH 间接在 Windows x86_64 上使用。
        //
        unsafe extern "C" fn rust_eh_personality_impl(
            version: c_int,
            actions: uw::_Unwind_Action,
            _exception_class: uw::_Unwind_Exception_Class,
            exception_object: *mut uw::_Unwind_Exception,
            context: *mut uw::_Unwind_Context,
        ) -> uw::_Unwind_Reason_Code {
            if version != 1 {
                return uw::_URC_FATAL_PHASE1_ERROR;
            }
            let eh_action = match find_eh_action(context) {
                Ok(action) => action,
                Err(_) => return uw::_URC_FATAL_PHASE1_ERROR,
            };
            if actions as i32 & uw::_UA_SEARCH_PHASE as i32 != 0 {
                match eh_action {
                    EHAction::None | EHAction::Cleanup(_) => uw::_URC_CONTINUE_UNWIND,
                    EHAction::Catch(_) | EHAction::Filter(_) => uw::_URC_HANDLER_FOUND,
                    EHAction::Terminate => uw::_URC_FATAL_PHASE1_ERROR,
                }
            } else {
                match eh_action {
                    EHAction::None => uw::_URC_CONTINUE_UNWIND,
                    // 强制展开点击终止动作。
                    EHAction::Filter(_) if actions as i32 & uw::_UA_FORCE_UNWIND as i32 != 0 => uw::_URC_CONTINUE_UNWIND,
                    EHAction::Cleanup(lpad) | EHAction::Catch(lpad) | EHAction::Filter(lpad) => {
                        uw::_Unwind_SetGR(
                            context,
                            UNWIND_DATA_REG.0,
                            exception_object as uintptr_t,
                        );
                        uw::_Unwind_SetGR(context, UNWIND_DATA_REG.1, 0);
                        uw::_Unwind_SetIP(context, lpad);
                        uw::_URC_INSTALL_CONTEXT
                    }
                    EHAction::Terminate => uw::_URC_FATAL_PHASE2_ERROR,
                }
            }
        }

        cfg_if::cfg_if! {
            if #[cfg(all(windows, any(target_arch = "aarch64", target_arch = "x86_64"), target_env = "gnu"))] {
                // 在 x86_64 MinGW 目标上，展开机制为 SEH，但是 unwind 处理程序数据 (aka LSDA) 使用 GCC 兼容的编码。
                //
                #[lang = "eh_personality"]
                #[allow(nonstandard_style)]
                unsafe extern "C" fn rust_eh_personality(
                    exceptionRecord: *mut uw::EXCEPTION_RECORD,
                    establisherFrame: uw::LPVOID,
                    contextRecord: *mut uw::CONTEXT,
                    dispatcherContext: *mut uw::DISPATCHER_CONTEXT,
                ) -> uw::EXCEPTION_DISPOSITION {
                    uw::_GCC_specific_handler(
                        exceptionRecord,
                        establisherFrame,
                        contextRecord,
                        dispatcherContext,
                        rust_eh_personality_impl,
                    )
                }
            } else {
                // 我们大多数目标的 personality 例程。
                #[lang = "eh_personality"]
                unsafe extern "C" fn rust_eh_personality(
                    version: c_int,
                    actions: uw::_Unwind_Action,
                    exception_class: uw::_Unwind_Exception_Class,
                    exception_object: *mut uw::_Unwind_Exception,
                    context: *mut uw::_Unwind_Context,
                ) -> uw::_Unwind_Reason_Code {
                    rust_eh_personality_impl(
                        version,
                        actions,
                        exception_class,
                        exception_object,
                        context,
                    )
                }
            }
        }
    }
}

unsafe fn find_eh_action(context: *mut uw::_Unwind_Context) -> Result<EHAction, ()> {
    let lsda = uw::_Unwind_GetLanguageSpecificData(context) as *const u8;
    let mut ip_before_instr: c_int = 0;
    let ip = uw::_Unwind_GetIPInfo(context, &mut ip_before_instr);
    let eh_context = EHContext {
        // 返回地址指向调用指令后的 1 个字节，该地址可能在 LSDA 范围表中的下一个 IP 范围内。
        //
        //
        // `ip = -1` 具有特殊含义，所以使用包装 sub 来允许它
        ip: if ip_before_instr != 0 { ip } else { ip.wrapping_sub(1) },
        func_start: uw::_Unwind_GetRegionStart(context),
        get_text_start: &|| uw::_Unwind_GetTextRelBase(context),
        get_data_start: &|| uw::_Unwind_GetDataRelBase(context),
    };
    eh::find_eh_action(lsda, &eh_context)
}