Added uxTaskGetStackHighWaterMark2(), which is the same as uxTaskGetStackHighWaterMar...

Allows the task name parameter passed into xTaskCreate() to be NULL.

git-svn-id: https://svn.code.sf.net/p/freertos/code/trunk@2586 1d2547de-c912-0410-9cb9-b8ca96c0e9e2

diff --git a/FreeRTOS/Demo/CORTEX_MPU_Simulator_Keil_GCC/FreeRTOSConfig.h b/FreeRTOS/Demo/CORTEX_MPU_Simulator_Keil_GCC/FreeRTOSConfig.h
index ce4ce82a2985a02462256e9fd9ebacd6a4a2d40b..e8b04346aa5d5025a720628bd1d07d5200d15c1f 100644 (file)
--- a/FreeRTOS/Demo/CORTEX_MPU_Simulator_Keil_GCC/FreeRTOSConfig.h
+++ b/FreeRTOS/Demo/CORTEX_MPU_Simulator_Keil_GCC/FreeRTOSConfig.h
@@ -114,6 +114,7 @@ to exclude the API function. */
 #define INCLUDE_xTaskGetSchedulerState         1\r
 #define INCLUDE_xTaskGetIdleTaskHandle         1\r
 #define INCLUDE_uxTaskGetStackHighWaterMark 1\r
+#define INCLUDE_uxTaskGetStackHighWaterMark2 1\r
 \r
 /* Cortex-M specific definitions. */\r
 #ifdef __NVIC_PRIO_BITS\r

diff --git a/FreeRTOS/Demo/CORTEX_MPU_Simulator_Keil_GCC/Keil_Specific/RTOSDemo.uvoptx b/FreeRTOS/Demo/CORTEX_MPU_Simulator_Keil_GCC/Keil_Specific/RTOSDemo.uvoptx
index e07fcd2debd974a8ded5befc3f0597da42031ba6..740ec3bbb9a8041bbdb9f35fe62f803a878a5d1e 100644 (file)
--- a/FreeRTOS/Demo/CORTEX_MPU_Simulator_Keil_GCC/Keil_Specific/RTOSDemo.uvoptx
+++ b/FreeRTOS/Demo/CORTEX_MPU_Simulator_Keil_GCC/Keil_Specific/RTOSDemo.uvoptx
@@ -178,7 +178,7 @@
       <DebugFlag>
         <trace>0</trace>
         <periodic>1</periodic>
-        <aLwin>1</aLwin>
+        <aLwin>0</aLwin>
         <aCover>0</aCover>
         <aSer1>0</aSer1>
         <aSer2>0</aSer2>

diff --git a/FreeRTOS/Demo/CORTEX_MPU_Simulator_Keil_GCC/main.c b/FreeRTOS/Demo/CORTEX_MPU_Simulator_Keil_GCC/main.c
index 254e51cb78c1d66abab07fb1226b40a0cc28d642..1ccddbbe7965503da5ab4a3231d5877a2d13c64f 100644 (file)
--- a/FreeRTOS/Demo/CORTEX_MPU_Simulator_Keil_GCC/main.c
+++ b/FreeRTOS/Demo/CORTEX_MPU_Simulator_Keil_GCC/main.c
@@ -766,6 +766,7 @@ static void prvTaskToDelete( void *pvParameters )
 \r
        /* For code coverage test purposes it is deleted by the Idle task. */\r
        configASSERT( uxTaskGetStackHighWaterMark( NULL ) > 0 );\r
+       configASSERT( uxTaskGetStackHighWaterMark2( NULL ) > 0 );\r
        vTaskSuspend( NULL );\r
 }\r
 /*-----------------------------------------------------------*/\r
@@ -1057,7 +1058,7 @@ void vApplicationMallocFailedHook( void )
 }\r
 /*-----------------------------------------------------------*/\r
 \r
-static void prvTimerCallback( TaskHandle_t xExpiredTimer )\r
+static void prvTimerCallback( TimerHandle_t xExpiredTimer )\r
 {\r
 uint32_t ulCount;\r
 \r

diff --git a/FreeRTOS/Demo/Common/Minimal/StaticAllocation.c b/FreeRTOS/Demo/Common/Minimal/StaticAllocation.c
index 32856726843d66f501dbf447ca3086dfb4bf0e98..e093467fbb9bf388c7391221b10ff4b2bc003935 100644 (file)
--- a/FreeRTOS/Demo/Common/Minimal/StaticAllocation.c
+++ b/FreeRTOS/Demo/Common/Minimal/StaticAllocation.c
@@ -729,7 +729,9 @@ TaskHandle_t xCreatedTask;
 \r
 /* The variable that will hold the TCB of tasks created by this function.  See\r
 the comments above the declaration of the xCreatorTaskTCBBuffer variable for\r
-more information. */\r
+more information.  NOTE:  This is not static so relies on the tasks that use it\r
+being deleted before this function returns and deallocates its stack.  That will\r
+only be the case if configUSE_PREEMPTION is set to 1. */\r
 StaticTask_t xTCBBuffer;\r
 \r
 /* This buffer that will be used as the stack of tasks created by this function.\r

diff --git a/FreeRTOS/Demo/WIN32-MingW/FreeRTOSConfig.h b/FreeRTOS/Demo/WIN32-MingW/FreeRTOSConfig.h
index f70cf1b76b53674ae8fff12e14d05e0af126f369..ef07b7609562d8ff05ff8c218f61949dc5b8af45 100644 (file)
--- a/FreeRTOS/Demo/WIN32-MingW/FreeRTOSConfig.h
+++ b/FreeRTOS/Demo/WIN32-MingW/FreeRTOSConfig.h
@@ -104,6 +104,7 @@ functions anyway. */
 #define INCLUDE_vTaskDelayUntil                                        1\r
 #define INCLUDE_vTaskDelay                                             1\r
 #define INCLUDE_uxTaskGetStackHighWaterMark            1\r
+#define INCLUDE_uxTaskGetStackHighWaterMark2   1\r
 #define INCLUDE_xTaskGetSchedulerState                 1\r
 #define INCLUDE_xTimerGetTimerDaemonTaskHandle 1\r
 #define INCLUDE_xTaskGetIdleTaskHandle                 1\r

diff --git a/FreeRTOS/Demo/WIN32-MingW/code_coverage_additions.c b/FreeRTOS/Demo/WIN32-MingW/code_coverage_additions.c
index 739005d5d48d1580f8215ce0c885694b69fa1e7b..5aafe110b95e392d343fc10b1fa893deb9f7cfee 100644 (file)
--- a/FreeRTOS/Demo/WIN32-MingW/code_coverage_additions.c
+++ b/FreeRTOS/Demo/WIN32-MingW/code_coverage_additions.c
@@ -381,6 +381,11 @@ const uint32_t ulRunTimeTollerance = ( uint32_t ) 0xfff;
                xReturn = pdFAIL;\r
        }\r
 \r
+       if( uxTaskGetStackHighWaterMark2( NULL ) != ( configSTACK_DEPTH_TYPE ) xStatus.usStackHighWaterMark )\r
+       {\r
+               xReturn = pdFAIL;\r
+       }\r
+\r
        /* Now obtain a task status without the high water mark but with the state,\r
        which in the case of the idle task should be Read. */\r
        xTimerTask = xTimerGetTimerDaemonTaskHandle();\r
@@ -408,6 +413,10 @@ const uint32_t ulRunTimeTollerance = ( uint32_t ) 0xfff;
        {\r
                xReturn = pdFAIL;\r
        }\r
+       if( uxTaskGetStackHighWaterMark2( xTimerTask ) != ( configSTACK_DEPTH_TYPE ) xStatus.usStackHighWaterMark )\r
+       {\r
+               xReturn = pdFAIL;\r
+       }\r
 \r
        /* Attempting to abort a delay in the idle task should be guaranteed to\r
        fail as the idle task should never block. */\r

diff --git a/FreeRTOS/Demo/WIN32-MingW/main_full.c b/FreeRTOS/Demo/WIN32-MingW/main_full.c
index be6b32b18099050d6e482dad8ddc789fb787321c..b6f59aafc11324acdf2c474d7b419f404f47bf42 100644 (file)
--- a/FreeRTOS/Demo/WIN32-MingW/main_full.c
+++ b/FreeRTOS/Demo/WIN32-MingW/main_full.c
@@ -201,7 +201,7 @@ int main_full( void )
        vStartDynamicPriorityTasks();\r
        vStartQueueSetTasks();\r
        vStartQueueOverwriteTask( mainQUEUE_OVERWRITE_PRIORITY );\r
-       xTaskCreate( prvDemoQueueSpaceFunctions, "QSpace", configMINIMAL_STACK_SIZE, NULL, tskIDLE_PRIORITY, NULL );\r
+       xTaskCreate( prvDemoQueueSpaceFunctions, NULL, configMINIMAL_STACK_SIZE, NULL, tskIDLE_PRIORITY, NULL ); /* Name is null for code coverage. */\r
        vStartEventGroupTasks();\r
        vStartInterruptSemaphoreTasks();\r
        vStartQueueSetPollingTask();\r

diff --git a/FreeRTOS/Source/include/FreeRTOS.h b/FreeRTOS/Source/include/FreeRTOS.h
index 9ea19416a91f490fedb4da2b0a9c476b24b8b122..9329e0cff070c87b375f54f29a95adc6a19690cd 100644 (file)
--- a/FreeRTOS/Source/include/FreeRTOS.h
+++ b/FreeRTOS/Source/include/FreeRTOS.h
@@ -156,6 +156,10 @@ extern "C" {
        #define INCLUDE_uxTaskGetStackHighWaterMark 0\r
 #endif\r
 \r
+#ifndef INCLUDE_uxTaskGetStackHighWaterMark2\r
+       #define INCLUDE_uxTaskGetStackHighWaterMark2 0\r
+#endif\r
+\r
 #ifndef INCLUDE_eTaskGetState\r
        #define INCLUDE_eTaskGetState 0\r
 #endif\r

diff --git a/FreeRTOS/Source/include/mpu_prototypes.h b/FreeRTOS/Source/include/mpu_prototypes.h
index b050371e512a12a0257d31ac2d975ca8e05b33d2..9b94922314d17d5beb4eceb8d1731fed83eff60c 100644 (file)
--- a/FreeRTOS/Source/include/mpu_prototypes.h
+++ b/FreeRTOS/Source/include/mpu_prototypes.h
@@ -61,6 +61,7 @@ UBaseType_t MPU_uxTaskGetNumberOfTasks( void );
 char * MPU_pcTaskGetName( TaskHandle_t xTaskToQuery );\r
 TaskHandle_t MPU_xTaskGetHandle( const char *pcNameToQuery );\r
 UBaseType_t MPU_uxTaskGetStackHighWaterMark( TaskHandle_t xTask );\r
+configSTACK_DEPTH_TYPE MPU_uxTaskGetStackHighWaterMark2( TaskHandle_t xTask );\r
 void MPU_vTaskSetApplicationTaskTag( TaskHandle_t xTask, TaskHookFunction_t pxHookFunction );\r
 TaskHookFunction_t MPU_xTaskGetApplicationTaskTag( TaskHandle_t xTask );\r
 void MPU_vTaskSetThreadLocalStoragePointer( TaskHandle_t xTaskToSet, BaseType_t xIndex, void *pvValue );\r

diff --git a/FreeRTOS/Source/include/mpu_wrappers.h b/FreeRTOS/Source/include/mpu_wrappers.h
index 641c8e63f0dca4942dcb36b7148dc19ac1d45f60..96e94ffe40466c35a897455ddf96c8c580c05897 100644 (file)
--- a/FreeRTOS/Source/include/mpu_wrappers.h
+++ b/FreeRTOS/Source/include/mpu_wrappers.h
@@ -67,6 +67,7 @@ only for ports that are using the MPU. */
                #define pcTaskGetName                                                   MPU_pcTaskGetName\r
                #define xTaskGetHandle                                                  MPU_xTaskGetHandle\r
                #define uxTaskGetStackHighWaterMark                             MPU_uxTaskGetStackHighWaterMark\r
+               #define uxTaskGetStackHighWaterMark2                    MPU_uxTaskGetStackHighWaterMark2\r
                #define vTaskSetApplicationTaskTag                              MPU_vTaskSetApplicationTaskTag\r
                #define xTaskGetApplicationTaskTag                              MPU_xTaskGetApplicationTaskTag\r
                #define vTaskSetThreadLocalStoragePointer               MPU_vTaskSetThreadLocalStoragePointer\r

diff --git a/FreeRTOS/Source/include/task.h b/FreeRTOS/Source/include/task.h
index 1a5136e8dea69c39524c8b95a193bd6bd972eb97..a03ff82a6f702bd3e7e1c23c1c50e1ccc263af30 100644 (file)
--- a/FreeRTOS/Source/include/task.h
+++ b/FreeRTOS/Source/include/task.h
@@ -1413,6 +1413,12 @@ TaskHandle_t xTaskGetHandle( const char *pcNameToQuery ) PRIVILEGED_FUNCTION; /*
  * a value of 1 means 4 bytes) since the task started.  The smaller the returned\r
  * number the closer the task has come to overflowing its stack.\r
  *\r
+ * uxTaskGetStackHighWaterMark() and uxTaskGetStackHighWaterMark2() are the\r
+ * same except for their return type.  Using configSTACK_DEPTH_TYPE allows the\r
+ * user to determine the return type.  It gets around the problem of the value\r
+ * overflowing on 8-bit types without breaking backward compatibility for\r
+ * applications that expect an 8-bit return type.\r
+ *\r
  * @param xTask Handle of the task associated with the stack to be checked.\r
  * Set xTask to NULL to check the stack of the calling task.\r
  *\r
@@ -1422,6 +1428,33 @@ TaskHandle_t xTaskGetHandle( const char *pcNameToQuery ) PRIVILEGED_FUNCTION; /*
  */\r
 UBaseType_t uxTaskGetStackHighWaterMark( TaskHandle_t xTask ) PRIVILEGED_FUNCTION;\r
 \r
+/**\r
+ * task.h\r
+ * <PRE>configSTACK_DEPTH_TYPE uxTaskGetStackHighWaterMark2( TaskHandle_t xTask );</PRE>\r
+ *\r
+ * INCLUDE_uxTaskGetStackHighWaterMark2 must be set to 1 in FreeRTOSConfig.h for\r
+ * this function to be available.\r
+ *\r
+ * Returns the high water mark of the stack associated with xTask.  That is,\r
+ * the minimum free stack space there has been (in words, so on a 32 bit machine\r
+ * a value of 1 means 4 bytes) since the task started.  The smaller the returned\r
+ * number the closer the task has come to overflowing its stack.\r
+ *\r
+ * uxTaskGetStackHighWaterMark() and uxTaskGetStackHighWaterMark2() are the\r
+ * same except for their return type.  Using configSTACK_DEPTH_TYPE allows the\r
+ * user to determine the return type.  It gets around the problem of the value\r
+ * overflowing on 8-bit types without breaking backward compatibility for\r
+ * applications that expect an 8-bit return type.\r
+ *\r
+ * @param xTask Handle of the task associated with the stack to be checked.\r
+ * Set xTask to NULL to check the stack of the calling task.\r
+ *\r
+ * @return The smallest amount of free stack space there has been (in words, so\r
+ * actual spaces on the stack rather than bytes) since the task referenced by\r
+ * xTask was created.\r
+ */\r
+configSTACK_DEPTH_TYPE uxTaskGetStackHighWaterMark2( TaskHandle_t xTask ) PRIVILEGED_FUNCTION;\r
+\r
 /* When using trace macros it is sometimes necessary to include task.h before\r
 FreeRTOS.h.  When this is done TaskHookFunction_t will not yet have been defined,\r
 so the following two prototypes will cause a compilation error.  This can be\r

diff --git a/FreeRTOS/Source/portable/Common/mpu_wrappers.c b/FreeRTOS/Source/portable/Common/mpu_wrappers.c
index c48075db170305d810798fced32e02d3176e0ac0..cb86b793ee193ba48d0877422df80f74bc670d46 100644 (file)
--- a/FreeRTOS/Source/portable/Common/mpu_wrappers.c
+++ b/FreeRTOS/Source/portable/Common/mpu_wrappers.c
@@ -420,6 +420,19 @@ BaseType_t xRunningPrivileged = xPortRaisePrivilege();
 #endif\r
 /*-----------------------------------------------------------*/\r
 \r
+#if ( INCLUDE_uxTaskGetStackHighWaterMark2 == 1 )\r
+       configSTACK_DEPTH_TYPE MPU_uxTaskGetStackHighWaterMark2( TaskHandle_t xTask )\r
+       {\r
+       configSTACK_DEPTH_TYPE uxReturn;\r
+       BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
+\r
+               uxReturn = uxTaskGetStackHighWaterMark2( xTask );\r
+               vPortResetPrivilege( xRunningPrivileged );\r
+               return uxReturn;\r
+       }\r
+#endif\r
+/*-----------------------------------------------------------*/\r
+\r
 #if ( INCLUDE_xTaskGetCurrentTaskHandle == 1 )\r
        TaskHandle_t MPU_xTaskGetCurrentTaskHandle( void )\r
        {\r

diff --git a/FreeRTOS/Source/portable/ThirdParty/GCC/RISC-V/portasm.S b/FreeRTOS/Source/portable/ThirdParty/GCC/RISC-V/portasm.S
index 3a2f3fad20e04762eb4c2e387adbb306ba2e94c7..78b22652e0ef2dcbddc01ab995cf30676ac410f2 100644 (file)
--- a/FreeRTOS/Source/portable/ThirdParty/GCC/RISC-V/portasm.S
+++ b/FreeRTOS/Source/portable/ThirdParty/GCC/RISC-V/portasm.S
@@ -131,7 +131,7 @@
        STORE   x29, 28 * REGBYTES(sp)\r
        STORE   x30, 29 * REGBYTES(sp)\r
        STORE   x31, 30 * REGBYTES(sp)\r
-       \r
+\r
        /* Store current stackpointer in task control block (TCB) */\r
        LOAD    t0, pxCurrentTCB        //pointer\r
        STORE   sp, 0x0(t0)\r

diff --git a/FreeRTOS/Source/tasks.c b/FreeRTOS/Source/tasks.c
index f6009fcc757500359fafc286a440e3915e98c259..e494bbcefab10ed5ef3a63dbc97c5cd8ca9d2ed5 100644 (file)
--- a/FreeRTOS/Source/tasks.c
+++ b/FreeRTOS/Source/tasks.c
@@ -100,7 +100,7 @@ changed then the definition of StaticTask_t must also be updated. */
 /* If any of the following are set then task stacks are filled with a known\r
 value so the high water mark can be determined.  If none of the following are\r
 set then don't fill the stack so there is no unnecessary dependency on memset. */\r
-#if( ( configCHECK_FOR_STACK_OVERFLOW > 1 ) || ( configUSE_TRACE_FACILITY == 1 ) || ( INCLUDE_uxTaskGetStackHighWaterMark == 1 ) )\r
+#if( ( configCHECK_FOR_STACK_OVERFLOW > 1 ) || ( configUSE_TRACE_FACILITY == 1 ) || ( INCLUDE_uxTaskGetStackHighWaterMark == 1 ) || ( INCLUDE_uxTaskGetStackHighWaterMark2 == 1 ) )\r
        #define tskSET_NEW_STACKS_TO_KNOWN_VALUE        1\r
 #else\r
        #define tskSET_NEW_STACKS_TO_KNOWN_VALUE        0\r
@@ -521,7 +521,7 @@ static void prvAddCurrentTaskToDelayedList( TickType_t xTicksToWait, const BaseT
  * This function determines the 'high water mark' of the task stack by\r
  * determining how much of the stack remains at the original preset value.\r
  */\r
-#if ( ( configUSE_TRACE_FACILITY == 1 ) || ( INCLUDE_uxTaskGetStackHighWaterMark == 1 ) )\r
+#if ( ( configUSE_TRACE_FACILITY == 1 ) || ( INCLUDE_uxTaskGetStackHighWaterMark == 1 ) || ( INCLUDE_uxTaskGetStackHighWaterMark2 == 1 ) )\r
 \r
        static configSTACK_DEPTH_TYPE prvTaskCheckFreeStackSpace( const uint8_t * pucStackByte ) PRIVILEGED_FUNCTION;\r
 \r
@@ -861,8 +861,6 @@ UBaseType_t x;
                uxPriority &= ~portPRIVILEGE_BIT;\r
        #endif /* portUSING_MPU_WRAPPERS == 1 */\r
 \r
-       configASSERT( pcName );\r
-\r
        /* Avoid dependency on memset() if it is not required. */\r
        #if( tskSET_NEW_STACKS_TO_KNOWN_VALUE == 1 )\r
        {\r
@@ -905,26 +903,35 @@ UBaseType_t x;
        #endif /* portSTACK_GROWTH */\r
 \r
        /* Store the task name in the TCB. */\r
-       for( x = ( UBaseType_t ) 0; x < ( UBaseType_t ) configMAX_TASK_NAME_LEN; x++ )\r
+       if( pcName != NULL )\r
        {\r
-               pxNewTCB->pcTaskName[ x ] = pcName[ x ];\r
-\r
-               /* Don't copy all configMAX_TASK_NAME_LEN if the string is shorter than\r
-               configMAX_TASK_NAME_LEN characters just in case the memory after the\r
-               string is not accessible (extremely unlikely). */\r
-               if( pcName[ x ] == ( char ) 0x00 )\r
-               {\r
-                       break;\r
-               }\r
-               else\r
+               for( x = ( UBaseType_t ) 0; x < ( UBaseType_t ) configMAX_TASK_NAME_LEN; x++ )\r
                {\r
-                       mtCOVERAGE_TEST_MARKER();\r
+                       pxNewTCB->pcTaskName[ x ] = pcName[ x ];\r
+\r
+                       /* Don't copy all configMAX_TASK_NAME_LEN if the string is shorter than\r
+                       configMAX_TASK_NAME_LEN characters just in case the memory after the\r
+                       string is not accessible (extremely unlikely). */\r
+                       if( pcName[ x ] == ( char ) 0x00 )\r
+                       {\r
+                               break;\r
+                       }\r
+                       else\r
+                       {\r
+                               mtCOVERAGE_TEST_MARKER();\r
+                       }\r
                }\r
-       }\r
 \r
-       /* Ensure the name string is terminated in the case that the string length\r
-       was greater or equal to configMAX_TASK_NAME_LEN. */\r
-       pxNewTCB->pcTaskName[ configMAX_TASK_NAME_LEN - 1 ] = '\0';\r
+               /* Ensure the name string is terminated in the case that the string length\r
+               was greater or equal to configMAX_TASK_NAME_LEN. */\r
+               pxNewTCB->pcTaskName[ configMAX_TASK_NAME_LEN - 1 ] = '\0';\r
+       }\r
+       else\r
+       {\r
+               /* The task has not been given a name, so just ensure there is a NULL\r
+               terminator when it is read out. */\r
+               pxNewTCB->pcTaskName[ 0 ] = 0x00;\r
+       }\r
 \r
        /* This is used as an array index so must ensure it's not too large.  First\r
        remove the privilege bit if one is present. */\r
@@ -3686,7 +3693,7 @@ static void prvCheckTasksWaitingTermination( void )
 #endif /* configUSE_TRACE_FACILITY */\r
 /*-----------------------------------------------------------*/\r
 \r
-#if ( ( configUSE_TRACE_FACILITY == 1 ) || ( INCLUDE_uxTaskGetStackHighWaterMark == 1 ) )\r
+#if ( ( configUSE_TRACE_FACILITY == 1 ) || ( INCLUDE_uxTaskGetStackHighWaterMark == 1 ) || ( INCLUDE_uxTaskGetStackHighWaterMark2 == 1 ) )\r
 \r
        static configSTACK_DEPTH_TYPE prvTaskCheckFreeStackSpace( const uint8_t * pucStackByte )\r
        {\r
@@ -3703,7 +3710,47 @@ static void prvCheckTasksWaitingTermination( void )
                return ( configSTACK_DEPTH_TYPE ) ulCount;\r
        }\r
 \r
-#endif /* ( ( configUSE_TRACE_FACILITY == 1 ) || ( INCLUDE_uxTaskGetStackHighWaterMark == 1 ) ) */\r
+#endif /* ( ( configUSE_TRACE_FACILITY == 1 ) || ( INCLUDE_uxTaskGetStackHighWaterMark == 1 ) || ( INCLUDE_uxTaskGetStackHighWaterMark2 == 1 ) ) */\r
+/*-----------------------------------------------------------*/\r
+\r
+#if ( INCLUDE_uxTaskGetStackHighWaterMark2 == 1 )\r
+\r
+       /* uxTaskGetStackHighWaterMark() and uxTaskGetStackHighWaterMark2() are the\r
+       same except for their return type.  Using configSTACK_DEPTH_TYPE allows the\r
+       user to determine the return type.  It gets around the problem of the value\r
+       overflowing on 8-bit types without breaking backward compatibility for\r
+       applications that expect an 8-bit return type. */\r
+       configSTACK_DEPTH_TYPE uxTaskGetStackHighWaterMark2( TaskHandle_t xTask )\r
+       {\r
+       TCB_t *pxTCB;\r
+       uint8_t *pucEndOfStack;\r
+       configSTACK_DEPTH_TYPE uxReturn;\r
+\r
+               /* uxTaskGetStackHighWaterMark() and uxTaskGetStackHighWaterMark2() are\r
+               the same except for their return type.  Using configSTACK_DEPTH_TYPE\r
+               allows the user to determine the return type.  It gets around the\r
+               problem of the value overflowing on 8-bit types without breaking\r
+               backward compatibility for applications that expect an 8-bit return\r
+               type. */\r
+\r
+               pxTCB = prvGetTCBFromHandle( xTask );\r
+\r
+               #if portSTACK_GROWTH < 0\r
+               {\r
+                       pucEndOfStack = ( uint8_t * ) pxTCB->pxStack;\r
+               }\r
+               #else\r
+               {\r
+                       pucEndOfStack = ( uint8_t * ) pxTCB->pxEndOfStack;\r
+               }\r
+               #endif\r
+\r
+               uxReturn = prvTaskCheckFreeStackSpace( pucEndOfStack );\r
+\r
+               return uxReturn;\r
+       }\r
+\r
+#endif /* INCLUDE_uxTaskGetStackHighWaterMark2 */\r
 /*-----------------------------------------------------------*/\r
 \r
 #if ( INCLUDE_uxTaskGetStackHighWaterMark == 1 )\r