rtos: convert CamelCase enum in uppercase

The eCos code is not part of this patch to prevent conflicts with
patches currently under review.

Change-Id: I71369165f2eef419b83a79ffcff50287f77949c6
Signed-off-by: Antonio Borneo <borneo.antonio@gmail.com>
Reviewed-on: http://openocd.zylin.com/6304
Tested-by: jenkins

diff --git a/src/rtos/FreeRTOS.c b/src/rtos/FreeRTOS.c
index 30c6e34cb480e915b47d93a7bf7c3b6b2f893014..24b82907048061c23c069adf365b725f1d794568 100644 (file)
--- a/src/rtos/FreeRTOS.c
+++ b/src/rtos/FreeRTOS.c
@@ -120,17 +120,17 @@ struct rtos_type FreeRTOS_rtos = {
 };
 
 enum FreeRTOS_symbol_values {
-       FreeRTOS_VAL_pxCurrentTCB = 0,
-       FreeRTOS_VAL_pxReadyTasksLists = 1,
-       FreeRTOS_VAL_xDelayedTaskList1 = 2,
-       FreeRTOS_VAL_xDelayedTaskList2 = 3,
-       FreeRTOS_VAL_pxDelayedTaskList = 4,
-       FreeRTOS_VAL_pxOverflowDelayedTaskList = 5,
-       FreeRTOS_VAL_xPendingReadyList = 6,
-       FreeRTOS_VAL_xTasksWaitingTermination = 7,
-       FreeRTOS_VAL_xSuspendedTaskList = 8,
-       FreeRTOS_VAL_uxCurrentNumberOfTasks = 9,
-       FreeRTOS_VAL_uxTopUsedPriority = 10,
+       FREERTOS_VAL_PX_CURRENT_TCB = 0,
+       FREERTOS_VAL_PX_READY_TASKS_LISTS = 1,
+       FREERTOS_VAL_X_DELAYED_TASK_LIST1 = 2,
+       FREERTOS_VAL_X_DELAYED_TASK_LIST2 = 3,
+       FREERTOS_VAL_PX_DELAYED_TASK_LIST = 4,
+       FREERTOS_VAL_PX_OVERFLOW_DELAYED_TASK_LIST = 5,
+       FREERTOS_VAL_X_PENDING_READY_LIST = 6,
+       FREERTOS_VAL_X_TASKS_WAITING_TERMINATION = 7,
+       FREERTOS_VAL_X_SUSPENDED_TASK_LIST = 8,
+       FREERTOS_VAL_UX_CURRENT_NUMBER_OF_TASKS = 9,
+       FREERTOS_VAL_UX_TOP_USED_PRIORITY = 10,
 };
 
 struct symbols {
@@ -174,17 +174,17 @@ static int FreeRTOS_update_threads(struct rtos *rtos)
                return -3;
        }
 
-       if (rtos->symbols[FreeRTOS_VAL_uxCurrentNumberOfTasks].address == 0) {
+       if (rtos->symbols[FREERTOS_VAL_UX_CURRENT_NUMBER_OF_TASKS].address == 0) {
                LOG_ERROR("Don't have the number of threads in FreeRTOS");
                return -2;
        }
 
        uint32_t thread_list_size = 0;
        retval = target_read_u32(rtos->target,
-                       rtos->symbols[FreeRTOS_VAL_uxCurrentNumberOfTasks].address,
+                       rtos->symbols[FREERTOS_VAL_UX_CURRENT_NUMBER_OF_TASKS].address,
                        &thread_list_size);
        LOG_DEBUG("FreeRTOS: Read uxCurrentNumberOfTasks at 0x%" PRIx64 ", value %" PRIu32,
-                                                                               rtos->symbols[FreeRTOS_VAL_uxCurrentNumberOfTasks].address,
+                                                                               rtos->symbols[FREERTOS_VAL_UX_CURRENT_NUMBER_OF_TASKS].address,
                                                                                thread_list_size);
 
        if (retval != ERROR_OK) {
@@ -198,7 +198,7 @@ static int FreeRTOS_update_threads(struct rtos *rtos)
        /* read the current thread */
        uint32_t pointer_casts_are_bad;
        retval = target_read_u32(rtos->target,
-                       rtos->symbols[FreeRTOS_VAL_pxCurrentTCB].address,
+                       rtos->symbols[FREERTOS_VAL_PX_CURRENT_TCB].address,
                        &pointer_casts_are_bad);
        if (retval != ERROR_OK) {
                LOG_ERROR("Error reading current thread in FreeRTOS thread list");
@@ -206,7 +206,7 @@ static int FreeRTOS_update_threads(struct rtos *rtos)
        }
        rtos->current_thread = pointer_casts_are_bad;
        LOG_DEBUG("FreeRTOS: Read pxCurrentTCB at 0x%" PRIx64 ", value 0x%" PRIx64,
-                                                                               rtos->symbols[FreeRTOS_VAL_pxCurrentTCB].address,
+                                                                               rtos->symbols[FREERTOS_VAL_PX_CURRENT_TCB].address,
                                                                                rtos->current_thread);
 
        if ((thread_list_size  == 0) || (rtos->current_thread == 0)) {
@@ -243,18 +243,18 @@ static int FreeRTOS_update_threads(struct rtos *rtos)
        }
 
        /* Find out how many lists are needed to be read from pxReadyTasksLists, */
-       if (rtos->symbols[FreeRTOS_VAL_uxTopUsedPriority].address == 0) {
+       if (rtos->symbols[FREERTOS_VAL_UX_TOP_USED_PRIORITY].address == 0) {
                LOG_ERROR("FreeRTOS: uxTopUsedPriority is not defined, consult the OpenOCD manual for a work-around");
                return ERROR_FAIL;
        }
        uint32_t top_used_priority = 0;
        retval = target_read_u32(rtos->target,
-                       rtos->symbols[FreeRTOS_VAL_uxTopUsedPriority].address,
+                       rtos->symbols[FREERTOS_VAL_UX_TOP_USED_PRIORITY].address,
                        &top_used_priority);
        if (retval != ERROR_OK)
                return retval;
        LOG_DEBUG("FreeRTOS: Read uxTopUsedPriority at 0x%" PRIx64 ", value %" PRIu32,
-                                                                               rtos->symbols[FreeRTOS_VAL_uxTopUsedPriority].address,
+                                                                               rtos->symbols[FREERTOS_VAL_UX_TOP_USED_PRIORITY].address,
                                                                                top_used_priority);
        if (top_used_priority > FREERTOS_MAX_PRIORITIES) {
                LOG_ERROR("FreeRTOS top used priority is unreasonably big, not proceeding: %" PRIu32,
@@ -278,14 +278,14 @@ static int FreeRTOS_update_threads(struct rtos *rtos)
 
        unsigned int num_lists;
        for (num_lists = 0; num_lists < config_max_priorities; num_lists++)
-               list_of_lists[num_lists] = rtos->symbols[FreeRTOS_VAL_pxReadyTasksLists].address +
+               list_of_lists[num_lists] = rtos->symbols[FREERTOS_VAL_PX_READY_TASKS_LISTS].address +
                        num_lists * param->list_width;
 
-       list_of_lists[num_lists++] = rtos->symbols[FreeRTOS_VAL_xDelayedTaskList1].address;
-       list_of_lists[num_lists++] = rtos->symbols[FreeRTOS_VAL_xDelayedTaskList2].address;
-       list_of_lists[num_lists++] = rtos->symbols[FreeRTOS_VAL_xPendingReadyList].address;
-       list_of_lists[num_lists++] = rtos->symbols[FreeRTOS_VAL_xSuspendedTaskList].address;
-       list_of_lists[num_lists++] = rtos->symbols[FreeRTOS_VAL_xTasksWaitingTermination].address;
+       list_of_lists[num_lists++] = rtos->symbols[FREERTOS_VAL_X_DELAYED_TASK_LIST1].address;
+       list_of_lists[num_lists++] = rtos->symbols[FREERTOS_VAL_X_DELAYED_TASK_LIST2].address;
+       list_of_lists[num_lists++] = rtos->symbols[FREERTOS_VAL_X_PENDING_READY_LIST].address;
+       list_of_lists[num_lists++] = rtos->symbols[FREERTOS_VAL_X_SUSPENDED_TASK_LIST].address;
+       list_of_lists[num_lists++] = rtos->symbols[FREERTOS_VAL_X_TASKS_WAITING_TERMINATION].address;
 
        for (unsigned int i = 0; i < num_lists; i++) {
                if (list_of_lists[i] == 0)
@@ -536,7 +536,7 @@ static int FreeRTOS_get_thread_ascii_info(struct rtos *rtos, threadid_t thread_i
 static bool FreeRTOS_detect_rtos(struct target *target)
 {
        if ((target->rtos->symbols != NULL) &&
-                       (target->rtos->symbols[FreeRTOS_VAL_pxReadyTasksLists].address != 0)) {
+                       (target->rtos->symbols[FREERTOS_VAL_PX_READY_TASKS_LISTS].address != 0)) {
                /* looks like FreeRTOS */
                return true;
        }

diff --git a/src/rtos/ThreadX.c b/src/rtos/ThreadX.c
index 53a74f8076ec9bc63ca7a2d756e303870ab04652..3b4c2d701d9d21b9dc9837987c4bd0c5487097a2 100644 (file)
--- a/src/rtos/ThreadX.c
+++ b/src/rtos/ThreadX.c
@@ -180,9 +180,9 @@ static const struct ThreadX_params ThreadX_params_list[] = {
 };
 
 enum ThreadX_symbol_values {
-       ThreadX_VAL_tx_thread_current_ptr = 0,
-       ThreadX_VAL_tx_thread_created_ptr = 1,
-       ThreadX_VAL_tx_thread_created_count = 2,
+       THREADX_VAL_TX_THREAD_CURRENT_PTR = 0,
+       THREADX_VAL_TX_THREAD_CREATED_PTR = 1,
+       THREADX_VAL_TX_THREAD_CREATED_COUNT = 2,
 };
 
 static const char * const ThreadX_symbol_list[] = {
@@ -276,14 +276,14 @@ static int ThreadX_update_threads(struct rtos *rtos)
                return -4;
        }
 
-       if (rtos->symbols[ThreadX_VAL_tx_thread_created_count].address == 0) {
+       if (rtos->symbols[THREADX_VAL_TX_THREAD_CREATED_COUNT].address == 0) {
                LOG_ERROR("Don't have the number of threads in ThreadX");
                return -2;
        }
 
        /* read the number of threads */
        retval = target_read_buffer(rtos->target,
-                       rtos->symbols[ThreadX_VAL_tx_thread_created_count].address,
+                       rtos->symbols[THREADX_VAL_TX_THREAD_CREATED_COUNT].address,
                        4,
                        (uint8_t *)&thread_list_size);
 
@@ -297,7 +297,7 @@ static int ThreadX_update_threads(struct rtos *rtos)
 
        /* read the current thread id */
        retval = target_read_buffer(rtos->target,
-                       rtos->symbols[ThreadX_VAL_tx_thread_current_ptr].address,
+                       rtos->symbols[THREADX_VAL_TX_THREAD_CURRENT_PTR].address,
                        4,
                        (uint8_t *)&rtos->current_thread);
 
@@ -334,7 +334,7 @@ static int ThreadX_update_threads(struct rtos *rtos)
        /* Read the pointer to the first thread */
        int64_t thread_ptr = 0;
        retval = target_read_buffer(rtos->target,
-                       rtos->symbols[ThreadX_VAL_tx_thread_created_ptr].address,
+                       rtos->symbols[THREADX_VAL_TX_THREAD_CREATED_PTR].address,
                        param->pointer_width,
                        (uint8_t *)&thread_ptr);
        if (retval != ERROR_OK) {
@@ -492,7 +492,7 @@ static int ThreadX_get_symbol_list_to_lookup(struct symbol_table_elem *symbol_li
 static bool ThreadX_detect_rtos(struct target *target)
 {
        if ((target->rtos->symbols != NULL) &&
-                       (target->rtos->symbols[ThreadX_VAL_tx_thread_created_ptr].address != 0)) {
+                       (target->rtos->symbols[THREADX_VAL_TX_THREAD_CREATED_PTR].address != 0)) {
                /* looks like ThreadX */
                return true;
        }

diff --git a/src/rtos/chromium-ec.c b/src/rtos/chromium-ec.c
index 1476f19690767fdd9bfec6e11beefe6f92919497..05d5b29b29038fba2acab01034d00d4400488e04 100644 (file)
--- a/src/rtos/chromium-ec.c
+++ b/src/rtos/chromium-ec.c
@@ -62,13 +62,13 @@ static const char * const chromium_ec_symbol_list[] = {
 };
 
 enum chromium_ec_symbol_values {
-       CHROMIUM_EC_VAL_start_called = 0,
-       CHROMIUM_EC_VAL_current_task,
-       CHROMIUM_EC_VAL_tasks,
-       CHROMIUM_EC_VAL_tasks_enabled,
-       CHROMIUM_EC_VAL_tasks_ready,
-       CHROMIUM_EC_VAL_task_names,
-       CHROMIUM_EC_VAL_build_info,
+       CHROMIUM_EC_VAL_START_CALLED = 0,
+       CHROMIUM_EC_VAL_CURRENT_TASK,
+       CHROMIUM_EC_VAL_TASKS,
+       CHROMIUM_EC_VAL_TASKS_ENABLED,
+       CHROMIUM_EC_VAL_TASKS_READY,
+       CHROMIUM_EC_VAL_TASK_NAMES,
+       CHROMIUM_EC_VAL_BUILD_INFO,
 
        CHROMIUM_EC_VAL_COUNT,
 };
@@ -84,7 +84,7 @@ static bool chromium_ec_detect_rtos(struct target *target)
        if (!target || !target->rtos || !target->rtos->symbols)
                return false;
 
-       for (sym = CHROMIUM_EC_VAL_start_called;
+       for (sym = CHROMIUM_EC_VAL_START_CALLED;
             sym < CHROMIUM_EC_VAL_COUNT; sym++) {
                if (target->rtos->symbols[sym].address) {
                        LOG_DEBUG("Chromium-EC: Symbol \"%s\" found",
@@ -97,7 +97,7 @@ static bool chromium_ec_detect_rtos(struct target *target)
        }
 
        ret = target_read_buffer(target,
-                                target->rtos->symbols[CHROMIUM_EC_VAL_build_info].address,
+                                target->rtos->symbols[CHROMIUM_EC_VAL_BUILD_INFO].address,
                                 sizeof(build_info_buf),
                                 (uint8_t *)build_info_buf);
 
@@ -107,7 +107,7 @@ static bool chromium_ec_detect_rtos(struct target *target)
        LOG_INFO("Chromium-EC: Buildinfo: %s", build_info_buf);
 
        return target->rtos->symbols &&
-              target->rtos->symbols[CHROMIUM_EC_VAL_start_called].address;
+              target->rtos->symbols[CHROMIUM_EC_VAL_START_CALLED].address;
 }
 
 static int chromium_ec_create(struct target *target)
@@ -143,7 +143,7 @@ static int chromium_ec_get_current_task_ptr(struct rtos *rtos, uint32_t *current
                return ERROR_FAIL;
 
        return target_read_u32(rtos->target,
-                              rtos->symbols[CHROMIUM_EC_VAL_current_task].address,
+                              rtos->symbols[CHROMIUM_EC_VAL_CURRENT_TASK].address,
                               current_task);
 }
 
@@ -153,7 +153,7 @@ static int chromium_ec_get_num_tasks(struct rtos *rtos, int *num_tasks)
        int ret, t, found;
 
        ret = target_read_u32(rtos->target,
-                             rtos->symbols[CHROMIUM_EC_VAL_tasks_enabled].address,
+                             rtos->symbols[CHROMIUM_EC_VAL_TASKS_ENABLED].address,
                              &tasks_enabled);
        if (ret != ERROR_OK) {
                LOG_ERROR("Failed to determine #of tasks");
@@ -213,7 +213,7 @@ static int chromium_ec_update_threads(struct rtos *rtos)
 
        /* One check if task switching has started ... */
        start_called = 0;
-       ret = target_read_u32(rtos->target, rtos->symbols[CHROMIUM_EC_VAL_start_called].address,
+       ret = target_read_u32(rtos->target, rtos->symbols[CHROMIUM_EC_VAL_START_CALLED].address,
                              &start_called);
        if (ret != ERROR_OK) {
                LOG_ERROR("Failed to load start_called");
@@ -241,7 +241,7 @@ static int chromium_ec_update_threads(struct rtos *rtos)
        }
 
        tasks_enabled = 0;
-       ret = target_read_u32(rtos->target, rtos->symbols[CHROMIUM_EC_VAL_tasks_enabled].address,
+       ret = target_read_u32(rtos->target, rtos->symbols[CHROMIUM_EC_VAL_TASKS_ENABLED].address,
                              &tasks_enabled);
        if (ret != ERROR_OK) {
                LOG_ERROR("Failed to load tasks_enabled");
@@ -249,14 +249,14 @@ static int chromium_ec_update_threads(struct rtos *rtos)
        }
 
        tasks_ready = 0;
-       ret = target_read_u32(rtos->target, rtos->symbols[CHROMIUM_EC_VAL_tasks_ready].address,
+       ret = target_read_u32(rtos->target, rtos->symbols[CHROMIUM_EC_VAL_TASKS_READY].address,
                              &tasks_ready);
        if (ret != ERROR_OK) {
                LOG_ERROR("Failed to load tasks_ready");
                return ret;
        }
 
-       thread_ptr = rtos->symbols[CHROMIUM_EC_VAL_tasks].address;
+       thread_ptr = rtos->symbols[CHROMIUM_EC_VAL_TASKS].address;
 
        tasks_found = 0;
        for (t = 0; t < CROS_EC_MAX_TASKS; t++) {
@@ -268,7 +268,7 @@ static int chromium_ec_update_threads(struct rtos *rtos)
 
                rtos->thread_details[tasks_found].threadid = thread_ptr;
                ret = target_read_u32(rtos->target,
-                                        rtos->symbols[CHROMIUM_EC_VAL_task_names].address +
+                                        rtos->symbols[CHROMIUM_EC_VAL_TASK_NAMES].address +
                                         params->ptr_size * t, &name_ptr);
                if (ret != ERROR_OK) {
                        LOG_ERROR("Failed to read name_ptr");
@@ -348,7 +348,7 @@ static int chromium_ec_get_thread_reg_list(struct rtos *rtos,
                return ERROR_FAIL;
 
        ret = target_read_u32(rtos->target,
-                          rtos->symbols[CHROMIUM_EC_VAL_tasks].address +
+                          rtos->symbols[CHROMIUM_EC_VAL_TASKS].address +
                           params->task_offset_next * t,
                           &stack_ptr);
        if (ret != ERROR_OK) {

diff --git a/src/rtos/embKernel.c b/src/rtos/embKernel.c
index 994cbc091ee345d85521bfc8ab16b34b5759b766..620d16baa72958d0df3d918af7e4695487c796c4 100644 (file)
--- a/src/rtos/embKernel.c
+++ b/src/rtos/embKernel.c
@@ -49,12 +49,12 @@ struct rtos_type embKernel_rtos = {
 };
 
 enum {
-       SYMBOL_ID_sCurrentTask = 0,
-       SYMBOL_ID_sListReady = 1,
-       SYMBOL_ID_sListSleep = 2,
-       SYMBOL_ID_sListSuspended = 3,
-       SYMBOL_ID_sMaxPriorities = 4,
-       SYMBOL_ID_sCurrentTaskCount = 5,
+       SYMBOL_ID_S_CURRENT_TASK = 0,
+       SYMBOL_ID_S_LIST_READY = 1,
+       SYMBOL_ID_S_LIST_SLEEP = 2,
+       SYMBOL_ID_S_LIST_SUSPENDED = 3,
+       SYMBOL_ID_S_MAX_PRIORITIES = 4,
+       SYMBOL_ID_S_CURRENT_TASK_COUNT = 5,
 };
 
 static const char * const embKernel_symbol_list[] = {
@@ -111,7 +111,7 @@ static const struct embKernel_params embKernel_params_list[] = {
 static bool embKernel_detect_rtos(struct target *target)
 {
        if (target->rtos->symbols != NULL) {
-               if (target->rtos->symbols[SYMBOL_ID_sCurrentTask].address != 0)
+               if (target->rtos->symbols[SYMBOL_ID_S_CURRENT_TASK].address != 0)
                        return true;
        }
        return false;
@@ -198,7 +198,7 @@ static int embKernel_update_threads(struct rtos *rtos)
                return -4;
        }
 
-       if (rtos->symbols[SYMBOL_ID_sCurrentTask].address == 0) {
+       if (rtos->symbols[SYMBOL_ID_S_CURRENT_TASK].address == 0) {
                LOG_ERROR("Don't have the thread list head");
                return -2;
        }
@@ -208,7 +208,7 @@ static int embKernel_update_threads(struct rtos *rtos)
 
        param = (const struct embKernel_params *) rtos->rtos_specific_params;
 
-       retval = target_read_buffer(rtos->target, rtos->symbols[SYMBOL_ID_sCurrentTask].address, param->pointer_width,
+       retval = target_read_buffer(rtos->target, rtos->symbols[SYMBOL_ID_S_CURRENT_TASK].address, param->pointer_width,
                        (uint8_t *) &rtos->current_thread);
        if (retval != ERROR_OK) {
                LOG_ERROR("Error reading current thread in embKernel thread list");
@@ -216,13 +216,13 @@ static int embKernel_update_threads(struct rtos *rtos)
        }
 
        int64_t max_used_priority = 0;
-       retval = target_read_buffer(rtos->target, rtos->symbols[SYMBOL_ID_sMaxPriorities].address, param->pointer_width,
+       retval = target_read_buffer(rtos->target, rtos->symbols[SYMBOL_ID_S_MAX_PRIORITIES].address, param->pointer_width,
                        (uint8_t *) &max_used_priority);
        if (retval != ERROR_OK)
                return retval;
 
        int thread_list_size = 0;
-       retval = target_read_buffer(rtos->target, rtos->symbols[SYMBOL_ID_sCurrentTaskCount].address,
+       retval = target_read_buffer(rtos->target, rtos->symbols[SYMBOL_ID_S_CURRENT_TASK_COUNT].address,
                        param->thread_count_width, (uint8_t *) &thread_list_size);
 
        if (retval != ERROR_OK) {
@@ -243,7 +243,7 @@ static int embKernel_update_threads(struct rtos *rtos)
                /* Get first item in queue */
                int64_t iterable = 0;
                retval = target_read_buffer(rtos->target,
-                               rtos->symbols[SYMBOL_ID_sListReady].address + (pri * param->rtos_list_size), param->pointer_width,
+                               rtos->symbols[SYMBOL_ID_S_LIST_READY].address + (pri * param->rtos_list_size), param->pointer_width,
                                (uint8_t *) &iterable);
                if (retval != ERROR_OK)
                        return retval;
@@ -261,7 +261,7 @@ static int embKernel_update_threads(struct rtos *rtos)
        }
        /* Look for sleeping tasks */
        int64_t iterable = 0;
-       retval = target_read_buffer(rtos->target, rtos->symbols[SYMBOL_ID_sListSleep].address, param->pointer_width,
+       retval = target_read_buffer(rtos->target, rtos->symbols[SYMBOL_ID_S_LIST_SLEEP].address, param->pointer_width,
                        (uint8_t *) &iterable);
        if (retval != ERROR_OK)
                return retval;
@@ -279,7 +279,7 @@ static int embKernel_update_threads(struct rtos *rtos)
 
        /* Look for suspended tasks  */
        iterable = 0;
-       retval = target_read_buffer(rtos->target, rtos->symbols[SYMBOL_ID_sListSuspended].address, param->pointer_width,
+       retval = target_read_buffer(rtos->target, rtos->symbols[SYMBOL_ID_S_LIST_SUSPENDED].address, param->pointer_width,
                        (uint8_t *) &iterable);
        if (retval != ERROR_OK)
                return retval;

diff --git a/src/rtos/mqx.c b/src/rtos/mqx.c
index 9f895deed656d10ce1c8f319be76c36ee046a23c..377bca96c9d002e3e685e78bc867707df66fbeb1 100644 (file)
--- a/src/rtos/mqx.c
+++ b/src/rtos/mqx.c
@@ -49,8 +49,8 @@
 
 /* types */
 enum mqx_symbols {
-       mqx_VAL_mqx_kernel_data,
-       mqx_VAL_MQX_init_struct,
+       MQX_VAL_MQX_KERNEL_DATA,
+       MQX_VAL_MQX_INIT_STRUCT,
 };
 
 enum mqx_arch {
@@ -200,7 +200,7 @@ static int mqx_is_scheduler_running(
 
        /* get '_mqx_kernel_data' symbol */
        if (ERROR_OK != mqx_get_symbol(
-               rtos, mqx_VAL_mqx_kernel_data, &kernel_data_symbol
+               rtos, MQX_VAL_MQX_KERNEL_DATA, &kernel_data_symbol
        )) {
                return ERROR_FAIL;
        }
@@ -252,7 +252,7 @@ static bool mqx_detect_rtos(
 {
        if (
                (target->rtos->symbols != NULL) &&
-               (target->rtos->symbols[mqx_VAL_mqx_kernel_data].address != 0)
+               (target->rtos->symbols[MQX_VAL_MQX_KERNEL_DATA].address != 0)
        ) {
                return true;
        }
@@ -303,7 +303,7 @@ static int mqx_update_threads(
                return ERROR_FAIL;
        /* get kernel_data symbol */
        if (ERROR_OK != mqx_get_symbol(
-               rtos, mqx_VAL_mqx_kernel_data, &kernel_data_addr
+               rtos, MQX_VAL_MQX_KERNEL_DATA, &kernel_data_addr
        )) {
                return ERROR_FAIL;
        }
@@ -472,7 +472,7 @@ static int mqx_get_thread_reg_list(
                return ERROR_FAIL;
        /* get kernel_data symbol */
        if (ERROR_OK != mqx_get_symbol(
-               rtos, mqx_VAL_mqx_kernel_data, &kernel_data_addr
+               rtos, MQX_VAL_MQX_KERNEL_DATA, &kernel_data_addr
        )) {
                return ERROR_FAIL;
        }

diff --git a/src/rtos/uCOS-III.c b/src/rtos/uCOS-III.c
index d62a2199bae01349a360a3838c197830a83fcaa9..1aed4846f51144a2a23ab6a203521e9cd89b4057 100644 (file)
--- a/src/rtos/uCOS-III.c
+++ b/src/rtos/uCOS-III.c
@@ -101,18 +101,18 @@ static const char * const uCOS_III_symbol_list[] = {
 };
 
 enum uCOS_III_symbol_values {
-       uCOS_III_VAL_OSRunning,
-       uCOS_III_VAL_OSTCBCurPtr,
-       uCOS_III_VAL_OSTaskDbgListPtr,
-       uCOS_III_VAL_OSTaskQty,
+       UCOS_III_VAL_OS_RUNNING,
+       UCOS_III_VAL_OS_TCB_CUR_PTR,
+       UCOS_III_VAL_OS_TASK_DBG_LIST_PTR,
+       UCOS_III_VAL_OS_TASK_QTY,
 
        /* also see: contrib/rtos-helpers/uCOS-III-openocd.c */
-       uCOS_III_VAL_OS_TCB_StkPtr_offset,
-       uCOS_III_VAL_OS_TCB_NamePtr_offset,
-       uCOS_III_VAL_OS_TCB_TaskState_offset,
-       uCOS_III_VAL_OS_TCB_Prio_offset,
-       uCOS_III_VAL_OS_TCB_DbgPrevPtr_offset,
-       uCOS_III_VAL_OS_TCB_DbgNextPtr_offset,
+       UCOS_III_VAL_OS_TCB_STK_PTR_OFFSET,
+       UCOS_III_VAL_OS_TCB_NAME_PTR_OFFSET,
+       UCOS_III_VAL_OS_TCB_TASK_STATE_OFFSET,
+       UCOS_III_VAL_OS_TCB_PRIO_OFFSET,
+       UCOS_III_VAL_OS_TCB_DBG_PREV_PTR_OFFSET,
+       UCOS_III_VAL_OS_TCB_DBG_NEXT_PTR_OFFSET,
 };
 
 static const char * const uCOS_III_thread_state_list[] = {
@@ -173,7 +173,7 @@ static int uCOS_III_find_last_thread_address(struct rtos *rtos, symbol_address_t
        symbol_address_t thread_list_address = 0;
 
        retval = target_read_memory(rtos->target,
-                       rtos->symbols[uCOS_III_VAL_OSTaskDbgListPtr].address,
+                       rtos->symbols[UCOS_III_VAL_OS_TASK_DBG_LIST_PTR].address,
                        params->pointer_width,
                        1,
                        (void *)&thread_list_address);
@@ -212,27 +212,27 @@ static int uCOS_III_update_thread_offsets(struct rtos *rtos)
                symbol_address_t *thread_offset;
        } thread_offset_maps[] = {
                {
-                       uCOS_III_VAL_OS_TCB_StkPtr_offset,
+                       UCOS_III_VAL_OS_TCB_STK_PTR_OFFSET,
                        &params->thread_stack_offset,
                },
                {
-                       uCOS_III_VAL_OS_TCB_NamePtr_offset,
+                       UCOS_III_VAL_OS_TCB_NAME_PTR_OFFSET,
                        &params->thread_name_offset,
                },
                {
-                       uCOS_III_VAL_OS_TCB_TaskState_offset,
+                       UCOS_III_VAL_OS_TCB_TASK_STATE_OFFSET,
                        &params->thread_state_offset,
                },
                {
-                       uCOS_III_VAL_OS_TCB_Prio_offset,
+                       UCOS_III_VAL_OS_TCB_PRIO_OFFSET,
                        &params->thread_priority_offset,
                },
                {
-                       uCOS_III_VAL_OS_TCB_DbgPrevPtr_offset,
+                       UCOS_III_VAL_OS_TCB_DBG_PREV_PTR_OFFSET,
                        &params->thread_prev_offset,
                },
                {
-                       uCOS_III_VAL_OS_TCB_DbgNextPtr_offset,
+                       UCOS_III_VAL_OS_TCB_DBG_NEXT_PTR_OFFSET,
                        &params->thread_next_offset,
                },
        };
@@ -258,7 +258,7 @@ static int uCOS_III_update_thread_offsets(struct rtos *rtos)
 static bool uCOS_III_detect_rtos(struct target *target)
 {
        return target->rtos->symbols != NULL &&
-                       target->rtos->symbols[uCOS_III_VAL_OSRunning].address != 0;
+                       target->rtos->symbols[UCOS_III_VAL_OS_RUNNING].address != 0;
 }
 
 static int uCOS_III_reset_handler(struct target *target, enum target_reset_mode reset_mode, void *priv)
@@ -312,7 +312,7 @@ static int uCOS_III_update_threads(struct rtos *rtos)
        uint8_t rtos_running;
 
        retval = target_read_u8(rtos->target,
-                       rtos->symbols[uCOS_III_VAL_OSRunning].address,
+                       rtos->symbols[UCOS_III_VAL_OS_RUNNING].address,
                        &rtos_running);
        if (retval != ERROR_OK) {
                LOG_ERROR("uCOS-III: failed to read RTOS running");
@@ -350,7 +350,7 @@ static int uCOS_III_update_threads(struct rtos *rtos)
        symbol_address_t current_thread_address = 0;
 
        retval = target_read_memory(rtos->target,
-                       rtos->symbols[uCOS_III_VAL_OSTCBCurPtr].address,
+                       rtos->symbols[UCOS_III_VAL_OS_TCB_CUR_PTR].address,
                        params->pointer_width,
                        1,
                        (void *)&current_thread_address);
@@ -361,7 +361,7 @@ static int uCOS_III_update_threads(struct rtos *rtos)
 
        /* read number of tasks */
        retval = target_read_u16(rtos->target,
-                       rtos->symbols[uCOS_III_VAL_OSTaskQty].address,
+                       rtos->symbols[UCOS_III_VAL_OS_TASK_QTY].address,
                        (void *)&rtos->thread_count);
        if (retval != ERROR_OK) {
                LOG_ERROR("uCOS-III: failed to read thread count");