[freertos] / FreeRTOS / Demo / CORTEX_M0+_LPC51U68_LPCXpresso / GCC_specific / semihost_hardfault.c

// ****************************************************************************\r
// semihost_hardfault.c\r
//                - Provides hard fault handler to allow semihosting code not\r
//                  to hang application when debugger not connected.\r
//\r
// ****************************************************************************\r
// Copyright 2017-2019 NXP\r
// All rights reserved.\r
//\r
// Software that is described herein is for illustrative purposes only\r
// which provides customers with programming information regarding the\r
// NXP Cortex-M based MCUs. This software is supplied "AS IS" without any\r
// warranties of any kind, and NXP Semiconductors and its licensor disclaim any\r
// and all warranties, express or implied, including all implied warranties of\r
// merchantability, fitness for a particular purpose and non-infringement of\r
// intellectual property rights.  NXP Semiconductors assumes no responsibility\r
// or liability for the use of the software, conveys no license or rights under\r
// any patent, copyright, mask work right, or any other intellectual property\r
// rights in or to any products. NXP Semiconductors reserves the right to make\r
// changes in the software without notification. NXP Semiconductors also makes\r
// no representation or warranty that such application will be suitable for the\r
// specified use without further testing or modification.\r
//\r
// Permission to use, copy, modify, and distribute this software and its\r
// documentation is hereby granted, under NXP Semiconductors' and its\r
// licensor's relevant copyrights in the software, without fee, provided that it\r
// is used in conjunction with NXP Semiconductors microcontrollers.  This\r
// copyright, permission, and disclaimer notice must appear in all copies of\r
// this code.\r
// ****************************************************************************\r
//\r
//                       ===== DESCRIPTION =====\r
//\r
// One of the issues with applications that make use of semihosting operations\r
// (such as printf calls) is that the code will not execute correctly when the\r
// debugger is not connected. Generally this will show up with the application\r
// appearing to just hang. This may include the application running from reset\r
// or powering up the board (with the application already in FLASH), and also\r
// as the application failing to continue to execute after a debug session is\r
// terminated.\r
//\r
// The problem here is that the "bottom layer" of the semihosted variants of\r
// the C library, semihosting is implemented by a "BKPT 0xAB" instruction.\r
// When the debug tools are not connected, this instruction triggers a hard\r
// fault - and the default hard fault handler within an application will\r
// typically just contains an infinite loop - causing the application to\r
// appear to have hang when no debugger is connected.\r
//\r
// The below code provides an example hard fault handler which instead looks\r
// to see what the instruction that caused the hard fault was - and if it\r
// was a "BKPT 0xAB", then it instead returns back to the user application.\r
//\r
// In most cases this will allow applications containing semihosting\r
// operations to execute (to some degree) when the debugger is not connected.\r
//\r
// == NOTE ==\r
//\r
// Correct execution of the application containing semihosted operations\r
// which are vectored onto this hard fault handler cannot be guaranteed. This\r
// is because the handler may not return data or return codes that the higher\r
// level C library code or application code expects. This hard fault handler\r
// is meant as a development aid, and it is not recommended to leave\r
// semihosted code in a production build of your application!\r
//\r
// ****************************************************************************\r
\r
// Allow handler to be removed by setting a define (via command line)\r
#if !defined (__SEMIHOST_HARDFAULT_DISABLE)\r
\r
__attribute__((naked))\r
void HardFault_Handler(void){\r
    __asm(  ".syntax unified\n"\r
        // Check which stack is in use\r
            "MOVS   R0, #4  \n"\r
            "MOV    R1, LR  \n"\r
            "TST    R0, R1  \n"\r
            "BEQ    _MSP    \n"\r
            "MRS    R0, PSP \n"\r
            "B  _process      \n"\r
            "_MSP:  \n"\r
            "MRS    R0, MSP \n"\r
        // Load the instruction that triggered hard fault\r
        "_process:     \n"\r
            "LDR    R1,[R0,#24] \n"\r
            "LDRH    R2,[r1] \n"\r
        // Semihosting instruction is "BKPT 0xAB" (0xBEAB)\r
            "LDR    R3,=0xBEAB \n"\r
            "CMP     R2,R3 \n"\r
            "BEQ    _semihost_return \n"\r
        // Wasn't semihosting instruction so enter infinite loop\r
            "B . \n"\r
        // Was semihosting instruction, so adjust location to\r
        // return to by 1 instruction (2 bytes), then exit function\r
        "_semihost_return: \n"\r
            "ADDS    R1,#2 \n"\r
            "STR    R1,[R0,#24] \n"\r
        // Set a return value from semihosting operation.\r
        // 32 is slightly arbitrary, but appears to allow most\r
        // C Library IO functions sitting on top of semihosting to\r
        // continue to operate to some degree\r
                    "MOVS   R1,#32 \n"\r
                    "STR R1,[ R0,#0 ] \n" // R0 is at location 0 on stack\r
        // Return from hard fault handler to application\r
            "BX LR \n"\r
        ".syntax divided\n") ;\r
}\r
\r
#endif\r
\r