target/xtensa: fix final clang analyzer warning

[fw/openocd] / src / target / xtensa / xtensa.c

diff --git a/src/target/xtensa/xtensa.c b/src/target/xtensa/xtensa.c
index f331a86654d69b63a8de287f52700adb0522ba74..4dfff6ab414a1679ef1224a799b9e46ede3906ab 100644 (file)
--- a/src/target/xtensa/xtensa.c
+++ b/src/target/xtensa/xtensa.c
@@ -1,4 +1,4 @@
-/* SPDX-License-Identifier: GPL-2.0-or-later */
+// SPDX-License-Identifier: GPL-2.0-or-later
 
 /***************************************************************************
  *   Generic Xtensa target API for OpenOCD                                 *
@@ -498,17 +498,20 @@ static void xtensa_queue_exec_ins(struct xtensa *xtensa, uint32_t ins)
 
 static void xtensa_queue_exec_ins_wide(struct xtensa *xtensa, uint8_t *ops, uint8_t oplen)
 {
-       if ((oplen > 0) && (oplen <= 64)) {
-               uint32_t opsw[8] = { 0, 0, 0, 0, 0, 0, 0, 0 };  /* 8 DIRx regs: max width 64B */
-               uint8_t oplenw = (oplen + 3) / 4;
-               if (xtensa->target->endianness == TARGET_BIG_ENDIAN)
-                       buf_bswap32((uint8_t *)opsw, ops, oplenw * 4);
-               else
-                       memcpy(opsw, ops, oplen);
+       const int max_oplen = 64;       /* 8 DIRx regs: max width 64B */
+       if ((oplen > 0) && (oplen <= max_oplen)) {
+               uint8_t ops_padded[max_oplen];
+               memcpy(ops_padded, ops, oplen);
+               memset(ops_padded + oplen, 0, max_oplen - oplen);
+               unsigned int oplenw = DIV_ROUND_UP(oplen, sizeof(uint32_t));
                for (int32_t i = oplenw - 1; i > 0; i--)
-                       xtensa_queue_dbg_reg_write(xtensa, XDMREG_DIR0 + i, opsw[i]);
+                       xtensa_queue_dbg_reg_write(xtensa,
+                               XDMREG_DIR0 + i,
+                               target_buffer_get_u32(xtensa->target, &ops_padded[sizeof(uint32_t)*i]));
                /* Write DIR0EXEC last */
-               xtensa_queue_dbg_reg_write(xtensa, XDMREG_DIR0EXEC, opsw[0]);
+               xtensa_queue_dbg_reg_write(xtensa,
+                       XDMREG_DIR0EXEC,
+                       target_buffer_get_u32(xtensa->target, &ops_padded[0]));
        }
 }
 
@@ -956,7 +959,6 @@ int xtensa_assert_reset(struct target *target)
        struct xtensa *xtensa = target_to_xtensa(target);
 
        LOG_TARGET_DEBUG(target, "target_number=%i, begin", target->target_number);
-       target->state = TARGET_RESET;
        xtensa_queue_pwr_reg_write(xtensa,
                XDMREG_PWRCTL,
                PWRCTL_JTAGDEBUGUSE(xtensa) | PWRCTL_DEBUGWAKEUP(xtensa) | PWRCTL_MEMWAKEUP(xtensa) |
@@ -965,8 +967,12 @@ int xtensa_assert_reset(struct target *target)
        int res = xtensa_dm_queue_execute(&xtensa->dbg_mod);
        if (res != ERROR_OK)
                return res;
+
+       /* registers are now invalid */
        xtensa->reset_asserted = true;
-       return res;
+       register_cache_invalidate(xtensa->core_cache);
+       target->state = TARGET_RESET;
+       return ERROR_OK;
 }
 
 int xtensa_deassert_reset(struct target *target)
@@ -1732,15 +1738,12 @@ int xtensa_read_memory(struct target *target, target_addr_t address, uint32_t si
                }
        }
 
-       if (addrstart_al == address && addrend_al == address + (size * count)) {
-               albuff = buffer;
-       } else {
-               albuff = malloc(addrend_al - addrstart_al);
-               if (!albuff) {
-                       LOG_TARGET_ERROR(target, "Out of memory allocating %" TARGET_PRIdADDR " bytes!",
-                               addrend_al - addrstart_al);
-                       return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
-               }
+       unsigned int alloc_bytes = ALIGN_UP(addrend_al - addrstart_al, sizeof(uint32_t));
+       albuff = calloc(alloc_bytes, 1);
+       if (!albuff) {
+               LOG_TARGET_ERROR(target, "Out of memory allocating %" PRId64 " bytes!",
+                       addrend_al - addrstart_al);
+               return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
        }
 
        /* We're going to use A3 here */
@@ -1789,11 +1792,8 @@ int xtensa_read_memory(struct target *target, target_addr_t address, uint32_t si
 
        if (bswap)
                buf_bswap32(albuff, albuff, addrend_al - addrstart_al);
-       if (albuff != buffer) {
-               memcpy(buffer, albuff + (address & 3), (size * count));
-               free(albuff);
-       }
-
+       memcpy(buffer, albuff + (address & 3), (size * count));
+       free(albuff);
        return res;
 }
 
@@ -1849,7 +1849,7 @@ int xtensa_write_memory(struct target *target,
                albuff = malloc(addrend_al - addrstart_al);
        }
        if (!albuff) {
-               LOG_TARGET_ERROR(target, "Out of memory allocating %" TARGET_PRIdADDR " bytes!",
+               LOG_TARGET_ERROR(target, "Out of memory allocating %" PRId64 " bytes!",
                        addrend_al - addrstart_al);
                return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
        }