Merge branch 'feature/efuse_remove_warnings_for_memcpy' into 'master'

all: Remove warnings for memcpy/memset

Closes IDF-6298

See merge request espressif/esp-idf!21164

components/bootloader_support/src/bootloader_common_loader.c

@@ -160,11 +160,7 @@ static void update_rtc_retain_mem_crc(void)
 
 NOINLINE_ATTR void bootloader_common_reset_rtc_retain_mem(void)
 {
-    #pragma GCC diagnostic push
-    #pragma GCC diagnostic ignored "-Wstringop-overflow"
-    #pragma GCC diagnostic ignored "-Warray-bounds"
-    memset(rtc_retain_mem, 0, sizeof(rtc_retain_mem_t));
-    #pragma GCC diagnostic pop
+    hal_memset(rtc_retain_mem, 0, sizeof(rtc_retain_mem_t));
 }
 
 uint16_t bootloader_common_get_rtc_retain_mem_reboot_counter(void)

components/efuse/esp32c2/esp_efuse_utility.c

@@ -101,26 +101,14 @@ esp_err_t esp_efuse_utility_burn_chip(void)
             if (esp_efuse_get_coding_scheme(num_block) == EFUSE_CODING_SCHEME_RS) {
                 uint8_t block_rs[12];
                 efuse_hal_rs_calculate((void *)range_write_addr_blocks[num_block].start, block_rs);
-#pragma GCC diagnostic push
-#ifndef __clang__
-#pragma GCC diagnostic ignored "-Wstringop-overflow"
-#endif
-#pragma GCC diagnostic ignored "-Warray-bounds"
-                memcpy((void *)EFUSE_PGM_CHECK_VALUE0_REG, block_rs, sizeof(block_rs));
-#pragma GCC diagnostic pop
+                hal_memcpy((void *)EFUSE_PGM_CHECK_VALUE0_REG, block_rs, sizeof(block_rs));
             }
             unsigned r_data_len = (range_read_addr_blocks[num_block].end - range_read_addr_blocks[num_block].start) + sizeof(uint32_t);
             unsigned data_len = (range_write_addr_blocks[num_block].end - range_write_addr_blocks[num_block].start) + sizeof(uint32_t);
             memcpy((void *)EFUSE_PGM_DATA0_REG, (void *)range_write_addr_blocks[num_block].start, data_len);
 
             uint32_t backup_write_data[8 + 3]; // 8 words are data and 3 words are RS coding data
-#pragma GCC diagnostic push
-#if     __GNUC__ >= 11
-#pragma GCC diagnostic ignored "-Wstringop-overread"
-#endif
-#pragma GCC diagnostic ignored "-Warray-bounds"
-            memcpy(backup_write_data, (void *)EFUSE_PGM_DATA0_REG, sizeof(backup_write_data));
-#pragma GCC diagnostic pop
+            hal_memcpy(backup_write_data, (void *)EFUSE_PGM_DATA0_REG, sizeof(backup_write_data));
             int repeat_burn_op = 1;
             bool correct_written_data;
             bool coding_error_before = efuse_hal_is_coding_error_in_block(num_block);
@@ -149,13 +137,7 @@ esp_err_t esp_efuse_utility_burn_chip(void)
                 correct_written_data = esp_efuse_utility_is_correct_written_data(num_block, r_data_len);
                 if (!correct_written_data || coding_error_occurred) {
                     ESP_LOGW(TAG, "BLOCK%d: next retry to fix an error [%d/3]...", num_block, repeat_burn_op);
-#pragma GCC diagnostic push
-#ifndef __clang__
-#pragma GCC diagnostic ignored "-Wstringop-overflow"
-#endif
-#pragma GCC diagnostic ignored "-Warray-bounds"
-                    memcpy((void *)EFUSE_PGM_DATA0_REG, (void *)backup_write_data, sizeof(backup_write_data));
-#pragma GCC diagnostic pop
+                    hal_memcpy((void *)EFUSE_PGM_DATA0_REG, (void *)backup_write_data, sizeof(backup_write_data));
                 }
 
             } while ((!correct_written_data || coding_error_occurred) && repeat_burn_op++ < 3);

components/efuse/esp32c3/esp_efuse_utility.c

@@ -130,26 +130,14 @@ esp_err_t esp_efuse_utility_burn_chip(void)
             if (esp_efuse_get_coding_scheme(num_block) == EFUSE_CODING_SCHEME_RS) {
                 uint8_t block_rs[12];
                 efuse_hal_rs_calculate((void *)range_write_addr_blocks[num_block].start, block_rs);
-#pragma GCC diagnostic push
-#ifndef __clang__
-#pragma GCC diagnostic ignored "-Wstringop-overflow"
-#endif
-#pragma GCC diagnostic ignored "-Warray-bounds"
-                memcpy((void *)EFUSE_PGM_CHECK_VALUE0_REG, block_rs, sizeof(block_rs));
-#pragma GCC diagnostic pop
+                hal_memcpy((void *)EFUSE_PGM_CHECK_VALUE0_REG, block_rs, sizeof(block_rs));
             }
             unsigned r_data_len = (range_read_addr_blocks[num_block].end - range_read_addr_blocks[num_block].start) + sizeof(uint32_t);
             unsigned data_len = (range_write_addr_blocks[num_block].end - range_write_addr_blocks[num_block].start) + sizeof(uint32_t);
             memcpy((void *)EFUSE_PGM_DATA0_REG, (void *)range_write_addr_blocks[num_block].start, data_len);
 
             uint32_t backup_write_data[8 + 3]; // 8 words are data and 3 words are RS coding data
-#pragma GCC diagnostic push
-#if     __GNUC__ >= 11
-#pragma GCC diagnostic ignored "-Wstringop-overread"
-#endif
-#pragma GCC diagnostic ignored "-Warray-bounds"
-            memcpy(backup_write_data, (void *)EFUSE_PGM_DATA0_REG, sizeof(backup_write_data));
-#pragma GCC diagnostic pop
+            hal_memcpy(backup_write_data, (void *)EFUSE_PGM_DATA0_REG, sizeof(backup_write_data));
             int repeat_burn_op = 1;
             bool correct_written_data;
             bool coding_error_before = efuse_hal_is_coding_error_in_block(num_block);
@@ -178,13 +166,7 @@ esp_err_t esp_efuse_utility_burn_chip(void)
                 correct_written_data = esp_efuse_utility_is_correct_written_data(num_block, r_data_len);
                 if (!correct_written_data || coding_error_occurred) {
                     ESP_LOGW(TAG, "BLOCK%d: next retry to fix an error [%d/3]...", num_block, repeat_burn_op);
-#pragma GCC diagnostic push
-#ifndef __clang__
-#pragma GCC diagnostic ignored "-Wstringop-overflow"
-#endif
-#pragma GCC diagnostic ignored "-Warray-bounds"
-                    memcpy((void *)EFUSE_PGM_DATA0_REG, (void *)backup_write_data, sizeof(backup_write_data));
-#pragma GCC diagnostic pop
+                    hal_memcpy((void *)EFUSE_PGM_DATA0_REG, (void *)backup_write_data, sizeof(backup_write_data));
                 }
 
             } while ((!correct_written_data || coding_error_occurred) && repeat_burn_op++ < 3);

components/efuse/esp32c6/esp_efuse_utility.c

@@ -115,26 +115,14 @@ esp_err_t esp_efuse_utility_burn_chip(void)
             if (esp_efuse_get_coding_scheme(num_block) == EFUSE_CODING_SCHEME_RS) {
                 uint8_t block_rs[12];
                 efuse_hal_rs_calculate((void *)range_write_addr_blocks[num_block].start, block_rs);
-#pragma GCC diagnostic push
-#ifndef __clang__
-#pragma GCC diagnostic ignored "-Wstringop-overflow"
-#endif
-#pragma GCC diagnostic ignored "-Warray-bounds"
-                memcpy((void *)EFUSE_PGM_CHECK_VALUE0_REG, block_rs, sizeof(block_rs));
-#pragma GCC diagnostic pop
+                hal_memcpy((void *)EFUSE_PGM_CHECK_VALUE0_REG, block_rs, sizeof(block_rs));
             }
             unsigned r_data_len = (range_read_addr_blocks[num_block].end - range_read_addr_blocks[num_block].start) + sizeof(uint32_t);
             unsigned data_len = (range_write_addr_blocks[num_block].end - range_write_addr_blocks[num_block].start) + sizeof(uint32_t);
             memcpy((void *)EFUSE_PGM_DATA0_REG, (void *)range_write_addr_blocks[num_block].start, data_len);
 
             uint32_t backup_write_data[8 + 3]; // 8 words are data and 3 words are RS coding data
-#pragma GCC diagnostic push
-#if     __GNUC__ >= 11
-#pragma GCC diagnostic ignored "-Wstringop-overread"
-#endif
-#pragma GCC diagnostic ignored "-Warray-bounds"
-            memcpy(backup_write_data, (void *)EFUSE_PGM_DATA0_REG, sizeof(backup_write_data));
-#pragma GCC diagnostic pop
+            hal_memcpy(backup_write_data, (void *)EFUSE_PGM_DATA0_REG, sizeof(backup_write_data));
             int repeat_burn_op = 1;
             bool correct_written_data;
             bool coding_error_before = efuse_hal_is_coding_error_in_block(num_block);
@@ -163,13 +151,7 @@ esp_err_t esp_efuse_utility_burn_chip(void)
                 correct_written_data = esp_efuse_utility_is_correct_written_data(num_block, r_data_len);
                 if (!correct_written_data || coding_error_occurred) {
                     ESP_LOGW(TAG, "BLOCK%d: next retry to fix an error [%d/3]...", num_block, repeat_burn_op);
-#pragma GCC diagnostic push
-#ifndef __clang__
-#pragma GCC diagnostic ignored "-Wstringop-overflow"
-#endif
-#pragma GCC diagnostic ignored "-Warray-bounds"
-                    memcpy((void *)EFUSE_PGM_DATA0_REG, (void *)backup_write_data, sizeof(backup_write_data));
-#pragma GCC diagnostic pop
+                    hal_memcpy((void *)EFUSE_PGM_DATA0_REG, (void *)backup_write_data, sizeof(backup_write_data));
                 }
 
             } while ((!correct_written_data || coding_error_occurred) && repeat_burn_op++ < 3);

components/efuse/esp32h4/esp_efuse_utility.c

@@ -115,26 +115,14 @@ esp_err_t esp_efuse_utility_burn_chip(void)
             if (esp_efuse_get_coding_scheme(num_block) == EFUSE_CODING_SCHEME_RS) {
                 uint8_t block_rs[12];
                 efuse_hal_rs_calculate((void *)range_write_addr_blocks[num_block].start, block_rs);
-#pragma GCC diagnostic push
-#ifndef __clang__
-#pragma GCC diagnostic ignored "-Wstringop-overflow"
-#endif
-#pragma GCC diagnostic ignored "-Warray-bounds"
-                memcpy((void *)EFUSE_PGM_CHECK_VALUE0_REG, block_rs, sizeof(block_rs));
-#pragma GCC diagnostic pop
+                hal_memcpy((void *)EFUSE_PGM_CHECK_VALUE0_REG, block_rs, sizeof(block_rs));
             }
             unsigned r_data_len = (range_read_addr_blocks[num_block].end - range_read_addr_blocks[num_block].start) + sizeof(uint32_t);
             unsigned data_len = (range_write_addr_blocks[num_block].end - range_write_addr_blocks[num_block].start) + sizeof(uint32_t);
             memcpy((void *)EFUSE_PGM_DATA0_REG, (void *)range_write_addr_blocks[num_block].start, data_len);
 
             uint32_t backup_write_data[8 + 3]; // 8 words are data and 3 words are RS coding data
-#pragma GCC diagnostic push
-#if     __GNUC__ >= 11
-#pragma GCC diagnostic ignored "-Wstringop-overread"
-#endif
-#pragma GCC diagnostic ignored "-Warray-bounds"
-            memcpy(backup_write_data, (void *)EFUSE_PGM_DATA0_REG, sizeof(backup_write_data));
-#pragma GCC diagnostic pop
+            hal_memcpy(backup_write_data, (void *)EFUSE_PGM_DATA0_REG, sizeof(backup_write_data));
             int repeat_burn_op = 1;
             bool correct_written_data;
             bool coding_error_before = efuse_hal_is_coding_error_in_block(num_block);
@@ -163,13 +151,7 @@ esp_err_t esp_efuse_utility_burn_chip(void)
                 correct_written_data = esp_efuse_utility_is_correct_written_data(num_block, r_data_len);
                 if (!correct_written_data || coding_error_occurred) {
                     ESP_LOGW(TAG, "BLOCK%d: next retry to fix an error [%d/3]...", num_block, repeat_burn_op);
-#pragma GCC diagnostic push
-#ifndef __clang__
-#pragma GCC diagnostic ignored "-Wstringop-overflow"
-#endif
-#pragma GCC diagnostic ignored "-Warray-bounds"
-                    memcpy((void *)EFUSE_PGM_DATA0_REG, (void *)backup_write_data, sizeof(backup_write_data));
-#pragma GCC diagnostic pop
+                    hal_memcpy((void *)EFUSE_PGM_DATA0_REG, (void *)backup_write_data, sizeof(backup_write_data));
                 }
 
             } while ((!correct_written_data || coding_error_occurred) && repeat_burn_op++ < 3);

components/efuse/esp32s2/esp_efuse_utility.c

@@ -115,26 +115,14 @@ esp_err_t esp_efuse_utility_burn_chip(void)
             if (esp_efuse_get_coding_scheme(num_block) == EFUSE_CODING_SCHEME_RS) {
                 uint8_t block_rs[12];
                 efuse_hal_rs_calculate((void *)range_write_addr_blocks[num_block].start, block_rs);
-#pragma GCC diagnostic push
-#ifndef __clang__
-#pragma GCC diagnostic ignored "-Wstringop-overflow"
-#endif
-#pragma GCC diagnostic ignored "-Warray-bounds"
-                memcpy((void *)EFUSE_PGM_CHECK_VALUE0_REG, block_rs, sizeof(block_rs));
-#pragma GCC diagnostic pop
+                hal_memcpy((void *)EFUSE_PGM_CHECK_VALUE0_REG, block_rs, sizeof(block_rs));
             }
             unsigned r_data_len = (range_read_addr_blocks[num_block].end - range_read_addr_blocks[num_block].start) + sizeof(uint32_t);
             unsigned data_len = (range_write_addr_blocks[num_block].end - range_write_addr_blocks[num_block].start) + sizeof(uint32_t);
             memcpy((void *)EFUSE_PGM_DATA0_REG, (void *)range_write_addr_blocks[num_block].start, data_len);
 
             uint32_t backup_write_data[8 + 3]; // 8 words are data and 3 words are RS coding data
-#pragma GCC diagnostic push
-#if     __GNUC__ >= 11
-#pragma GCC diagnostic ignored "-Wstringop-overread"
-#endif
-#pragma GCC diagnostic ignored "-Warray-bounds"
-            memcpy(backup_write_data, (void *)EFUSE_PGM_DATA0_REG, sizeof(backup_write_data));
-#pragma GCC diagnostic pop
+            hal_memcpy(backup_write_data, (void *)EFUSE_PGM_DATA0_REG, sizeof(backup_write_data));
             int repeat_burn_op = 1;
             bool correct_written_data;
             bool coding_error_before = efuse_hal_is_coding_error_in_block(num_block);
@@ -163,13 +151,7 @@ esp_err_t esp_efuse_utility_burn_chip(void)
                 correct_written_data = esp_efuse_utility_is_correct_written_data(num_block, r_data_len);
                 if (!correct_written_data || coding_error_occurred) {
                     ESP_LOGW(TAG, "BLOCK%d: next retry to fix an error [%d/3]...", num_block, repeat_burn_op);
-#pragma GCC diagnostic push
-#ifndef __clang__
-#pragma GCC diagnostic ignored "-Wstringop-overflow"
-#endif
-#pragma GCC diagnostic ignored "-Warray-bounds"
-                    memcpy((void *)EFUSE_PGM_DATA0_REG, (void *)backup_write_data, sizeof(backup_write_data));
-#pragma GCC diagnostic pop
+                    hal_memcpy((void *)EFUSE_PGM_DATA0_REG, (void *)backup_write_data, sizeof(backup_write_data));
                 }
 
             } while ((!correct_written_data || coding_error_occurred) && repeat_burn_op++ < 3);

components/efuse/esp32s3/esp_efuse_utility.c

@@ -115,26 +115,14 @@ esp_err_t esp_efuse_utility_burn_chip(void)
             if (esp_efuse_get_coding_scheme(num_block) == EFUSE_CODING_SCHEME_RS) {
                 uint8_t block_rs[12];
                 efuse_hal_rs_calculate((void *)range_write_addr_blocks[num_block].start, block_rs);
-#pragma GCC diagnostic push
-#ifndef __clang__
-#pragma GCC diagnostic ignored "-Wstringop-overflow"
-#endif
-#pragma GCC diagnostic ignored "-Warray-bounds"
-                memcpy((void *)EFUSE_PGM_CHECK_VALUE0_REG, block_rs, sizeof(block_rs));
-#pragma GCC diagnostic pop
+                hal_memcpy((void *)EFUSE_PGM_CHECK_VALUE0_REG, block_rs, sizeof(block_rs));
             }
             unsigned r_data_len = (range_read_addr_blocks[num_block].end - range_read_addr_blocks[num_block].start) + sizeof(uint32_t);
             unsigned data_len = (range_write_addr_blocks[num_block].end - range_write_addr_blocks[num_block].start) + sizeof(uint32_t);
             memcpy((void *)EFUSE_PGM_DATA0_REG, (void *)range_write_addr_blocks[num_block].start, data_len);
 
             uint32_t backup_write_data[8 + 3]; // 8 words are data and 3 words are RS coding data
-#pragma GCC diagnostic push
-#if     __GNUC__ >= 11
-#pragma GCC diagnostic ignored "-Wstringop-overread"
-#endif
-#pragma GCC diagnostic ignored "-Warray-bounds"
-            memcpy(backup_write_data, (void *)EFUSE_PGM_DATA0_REG, sizeof(backup_write_data));
-#pragma GCC diagnostic pop
+            hal_memcpy(backup_write_data, (void *)EFUSE_PGM_DATA0_REG, sizeof(backup_write_data));
             int repeat_burn_op = 1;
             bool correct_written_data;
             bool coding_error_before = efuse_hal_is_coding_error_in_block(num_block);
@@ -163,13 +151,7 @@ esp_err_t esp_efuse_utility_burn_chip(void)
                 correct_written_data = esp_efuse_utility_is_correct_written_data(num_block, r_data_len);
                 if (!correct_written_data || coding_error_occurred) {
                     ESP_LOGW(TAG, "BLOCK%d: next retry to fix an error [%d/3]...", num_block, repeat_burn_op);
-#pragma GCC diagnostic push
-#ifndef __clang__
-#pragma GCC diagnostic ignored "-Wstringop-overflow"
-#endif
-#pragma GCC diagnostic ignored "-Warray-bounds"
-                    memcpy((void *)EFUSE_PGM_DATA0_REG, (void *)backup_write_data, sizeof(backup_write_data));
-#pragma GCC diagnostic pop
+                    hal_memcpy((void *)EFUSE_PGM_DATA0_REG, (void *)backup_write_data, sizeof(backup_write_data));
                 }
 
             } while ((!correct_written_data || coding_error_occurred) && repeat_burn_op++ < 3);

components/esp_system/port/cpu_start.c

@@ -587,13 +587,7 @@ void IRAM_ATTR call_start_cpu0(void)
 #else
     // This assumes that DROM is the first segment in the application binary, i.e. that we can read
     // the binary header through cache by accessing SOC_DROM_LOW address.
-#pragma GCC diagnostic push
-#if     __GNUC__ >= 11
-#pragma GCC diagnostic ignored "-Wstringop-overread"
-#endif
-#pragma GCC diagnostic ignored "-Warray-bounds"
-    memcpy(&fhdr, (void *) SOC_DROM_LOW, sizeof(fhdr));
-#pragma GCC diagnostic pop
+    hal_memcpy(&fhdr, (void *) SOC_DROM_LOW, sizeof(fhdr));
 
 #endif // CONFIG_APP_BUILD_TYPE_ELF_RAM
 

components/hal/platform_port/include/hal/misc.h

@@ -1,18 +1,12 @@
-// Copyright 2021 Espressif Systems (Shanghai) PTE LTD
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
+/*
+ * SPDX-FileCopyrightText: 2021-2022 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
 #pragma once
 
+#include <string.h>
+
 #define HAL_SWAP16(d) __builtin_bswap16((d))
 #define HAL_SWAP32(d) __builtin_bswap32((d))
 #define HAL_SWAP64(d) __builtin_bswap64((d))
@@ -57,3 +51,35 @@
 })
 
 /** @endcond */
+
+/**
+ * @brief Copy data from memory array to another memory
+ *
+ * This helps bypass the -Warray-bounds, -Wstringop-overread and -Wstringop-overflow bugs.
+ *
+ * @param dst_mem Pointer to the destination of data
+ * @param src_mem Pointer to the source of data to be copied
+ * @param len The number of bytes to be copied
+ * @return a pointer to destination
+ */
+__attribute__((always_inline)) static inline void *hal_memcpy(void *dst_mem, const void *src_mem, size_t len)
+{
+    asm("" : "+r"(dst_mem), "+r"(src_mem));
+    return memcpy(dst_mem, src_mem, len);
+}
+
+/**
+ * @brief Sets the first num bytes of the block of memory pointed by ptr to the specified value
+ *
+ * This helps bypass the -Warray-bounds, -Wstringop-overread and -Wstringop-overflow bugs.
+ *
+ * @param dst_reg Pointer to the block of memory to fill
+ * @param value The value to be set.
+ * @param len The number of bytes to be copied
+ * @return a pointer to the memory area
+ */
+__attribute__((always_inline)) static inline void *hal_memset(void *dst_mem, int value, size_t len)
+{
+    asm("" : "+r"(dst_mem));
+    return memset(dst_mem, value, len);
+}

components/soc/include/soc/efuse_periph.h

@@ -7,3 +7,4 @@
 #pragma once
 #include "soc/efuse_reg.h"
 #include "soc/efuse_struct.h"
+#include "hal/misc.h"

components/ulp/test_apps/ulp_fsm/main/test_ulp.c

@@ -21,6 +21,7 @@
 #include "soc/rtc_cntl_reg.h"
 #include "soc/sens_reg.h"
 #include "soc/rtc_io_reg.h"
+#include "hal/misc.h"
 #include "driver/rtc_io.h"
 
 #include "sdkconfig.h"
@@ -50,12 +51,7 @@ static void hexdump(const uint32_t* src, size_t count) {
 
 TEST_CASE("ULP FSM addition test", "[ulp]")
 {
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wstringop-overflow"
-#pragma GCC diagnostic ignored "-Warray-bounds"
-    /* Clear the RTC_SLOW_MEM region for the ULP co-processor binary to be loaded */
-    memset(RTC_SLOW_MEM, 0, CONFIG_ULP_COPROC_RESERVE_MEM);
-#pragma GCC diagnostic pop
+    hal_memset(RTC_SLOW_MEM, 0, CONFIG_ULP_COPROC_RESERVE_MEM);
 
     /* ULP co-processor program to add data in 2 memory locations using ULP macros */
     const ulp_insn_t program[] = {
@@ -88,12 +84,8 @@ TEST_CASE("ULP FSM subtraction and branch test", "[ulp]")
 {
     assert(CONFIG_ULP_COPROC_RESERVE_MEM >= 260 && "this test needs ULP_COPROC_RESERVE_MEM option set in menuconfig");
 
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wstringop-overflow"
-#pragma GCC diagnostic ignored "-Warray-bounds"
     /* Clear the RTC_SLOW_MEM region for the ULP co-processor binary to be loaded */
-    memset(RTC_SLOW_MEM, 0, CONFIG_ULP_COPROC_RESERVE_MEM);
-#pragma GCC diagnostic pop
+    hal_memset(RTC_SLOW_MEM, 0, CONFIG_ULP_COPROC_RESERVE_MEM);
 
     /* ULP co-processor program to perform subtractions and branch to a label */
     const ulp_insn_t program[] = {
@@ -163,12 +155,8 @@ TEST_CASE("ULP FSM light-sleep wakeup test", "[ulp]")
 {
     assert(CONFIG_ULP_COPROC_RESERVE_MEM >= 260 && "this test needs ULP_COPROC_RESERVE_MEM option set in menuconfig");
 
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wstringop-overflow"
-#pragma GCC diagnostic ignored "-Warray-bounds"
     /* Clear the RTC_SLOW_MEM region for the ULP co-processor binary to be loaded */
-    memset(RTC_SLOW_MEM, 0, CONFIG_ULP_COPROC_RESERVE_MEM);
-#pragma GCC diagnostic pop
+    hal_memset(RTC_SLOW_MEM, 0, CONFIG_ULP_COPROC_RESERVE_MEM);
 
     /* ULP co-processor program to perform some activities and wakeup the main CPU from deep-sleep */
     const ulp_insn_t program[] = {
@@ -209,12 +197,8 @@ TEST_CASE("ULP FSM deep-sleep wakeup test", "[ulp][ulp_deep_sleep_wakeup]")
 {
     assert(CONFIG_ULP_COPROC_RESERVE_MEM >= 260 && "this test needs ULP_COPROC_RESERVE_MEM option set in menuconfig");
 
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wstringop-overflow"
-#pragma GCC diagnostic ignored "-Warray-bounds"
     /* Clearout the RTC_SLOW_MEM region for the ULP co-processor binary to be loaded */
-    memset(RTC_SLOW_MEM, 0, CONFIG_ULP_COPROC_RESERVE_MEM);
-#pragma GCC diagnostic pop
+    hal_memset(RTC_SLOW_MEM, 0, CONFIG_ULP_COPROC_RESERVE_MEM);
 
     /* ULP co-processor program to perform some activities and wakeup the main CPU from deep-sleep */
     const ulp_insn_t program[] = {
@@ -256,12 +240,8 @@ TEST_CASE("ULP FSM can write and read peripheral registers", "[ulp]")
     /* Clear ULP timer */
     CLEAR_PERI_REG_MASK(RTC_CNTL_STATE0_REG, RTC_CNTL_ULP_CP_SLP_TIMER_EN);
 
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wstringop-overflow"
-#pragma GCC diagnostic ignored "-Warray-bounds"
     /* Clear the RTC_SLOW_MEM region for the ULP co-processor binary to be loaded */
-    memset(RTC_SLOW_MEM, 0, CONFIG_ULP_COPROC_RESERVE_MEM);
-#pragma GCC diagnostic pop
+    hal_memset(RTC_SLOW_MEM, 0, CONFIG_ULP_COPROC_RESERVE_MEM);
     uint32_t rtc_store0 = REG_READ(RTC_CNTL_STORE0_REG);
     uint32_t rtc_store1 = REG_READ(RTC_CNTL_STORE1_REG);
 
@@ -315,12 +295,8 @@ TEST_CASE("ULP FSM I_WR_REG instruction test", "[ulp]")
 {
     assert(CONFIG_ULP_COPROC_RESERVE_MEM >= 260 && "this test needs ULP_COPROC_RESERVE_MEM option set in menuconfig");
 
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wstringop-overflow"
-#pragma GCC diagnostic ignored "-Warray-bounds"
     /* Clear the RTC_SLOW_MEM region for the ULP co-processor binary to be loaded */
-    memset(RTC_SLOW_MEM, 0, CONFIG_ULP_COPROC_RESERVE_MEM);
-#pragma GCC diagnostic pop
+    hal_memset(RTC_SLOW_MEM, 0, CONFIG_ULP_COPROC_RESERVE_MEM);
 
     /* Define the test set */
     typedef struct {
@@ -393,12 +369,8 @@ TEST_CASE("ULP FSM controls RTC_IO", "[ulp][ulp_deep_sleep_wakeup]")
 {
     assert(CONFIG_ULP_COPROC_RESERVE_MEM >= 260 && "this test needs ULP_COPROC_RESERVE_MEM option set in menuconfig");
 
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wstringop-overflow"
-#pragma GCC diagnostic ignored "-Warray-bounds"
     /* Clear the RTC_SLOW_MEM region for the ULP co-processor binary to be loaded */
-    memset(RTC_SLOW_MEM, 0, CONFIG_ULP_COPROC_RESERVE_MEM);
-#pragma GCC diagnostic pop
+    hal_memset(RTC_SLOW_MEM, 0, CONFIG_ULP_COPROC_RESERVE_MEM);
 
     /* ULP co-processor program to toggle LED */
     const ulp_insn_t program[] = {
@@ -459,20 +431,12 @@ TEST_CASE("ULP FSM power consumption in deep sleep", "[ulp][ulp_deep_sleep_wakeu
 {
     assert(CONFIG_ULP_COPROC_RESERVE_MEM >= 4 && "this test needs ULP_COPROC_RESERVE_MEM option set in menuconfig");
 
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wstringop-overflow"
-#pragma GCC diagnostic ignored "-Warray-bounds"
     /* Clear the RTC_SLOW_MEM region for the ULP co-processor binary to be loaded */
-    memset(RTC_SLOW_MEM, 0, CONFIG_ULP_COPROC_RESERVE_MEM);
-#pragma GCC diagnostic pop
+    hal_memset(RTC_SLOW_MEM, 0, CONFIG_ULP_COPROC_RESERVE_MEM);
 
     /* Put the ULP coprocessor in halt state */
     ulp_insn_t insn = I_HALT();
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wstringop-overflow"
-#pragma GCC diagnostic ignored "-Warray-bounds"
-    memcpy(&RTC_SLOW_MEM[0], &insn, sizeof(insn));
-#pragma GCC diagnostic pop
+    hal_memcpy(RTC_SLOW_MEM, &insn, sizeof(insn));
 
     /* Set ULP timer */
     ulp_set_wakeup_period(0, 0x8000);
@@ -493,12 +457,8 @@ TEST_CASE("ULP FSM timer setting", "[ulp]")
 {
     assert(CONFIG_ULP_COPROC_RESERVE_MEM >= 32 && "this test needs ULP_COPROC_RESERVE_MEM option set in menuconfig");
 
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wstringop-overflow"
-#pragma GCC diagnostic ignored "-Warray-bounds"
     /* Clear the RTC_SLOW_MEM region for the ULP co-processor binary to be loaded */
-    memset(RTC_SLOW_MEM, 0, CONFIG_ULP_COPROC_RESERVE_MEM);
-#pragma GCC diagnostic pop
+    hal_memset(RTC_SLOW_MEM, 0, CONFIG_ULP_COPROC_RESERVE_MEM);
 
     /*
      * Run a simple ULP program which increments the counter, for one second.
@@ -559,12 +519,8 @@ TEST_CASE("ULP FSM can use temperature sensor (TSENS) in deep sleep", "[ulp][ulp
 {
     assert(CONFIG_ULP_COPROC_RESERVE_MEM >= 260 && "this test needs ULP_COPROC_RESERVE_MEM option set in menuconfig");
 
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wstringop-overflow"
-#pragma GCC diagnostic ignored "-Warray-bounds"
     /* Clear the RTC_SLOW_MEM region for the ULP co-processor binary to be loaded */
-    memset(RTC_SLOW_MEM, 0, CONFIG_ULP_COPROC_RESERVE_MEM);
-#pragma GCC diagnostic pop
+    hal_memset(RTC_SLOW_MEM, 0, CONFIG_ULP_COPROC_RESERVE_MEM);
 
     // Allow TSENS to be controlled by the ULP
     SET_PERI_REG_BITS(SENS_SAR_TSENS_CTRL_REG, SENS_TSENS_CLK_DIV, 10, SENS_TSENS_CLK_DIV_S);
@@ -630,12 +586,8 @@ TEST_CASE("ULP FSM can use ADC in deep sleep", "[ulp][ulp_deep_sleep_wakeup]")
     const int channel = 0;
     const int atten = 0;
 
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wstringop-overflow"
-#pragma GCC diagnostic ignored "-Warray-bounds"
     /* Clear the RTC_SLOW_MEM region for the ULP co-processor binary to be loaded */
-    memset(RTC_SLOW_MEM, 0, CONFIG_ULP_COPROC_RESERVE_MEM);
-#pragma GCC diagnostic pop
+    hal_memset(RTC_SLOW_MEM, 0, CONFIG_ULP_COPROC_RESERVE_MEM);
 
 #if defined(CONFIG_IDF_TARGET_ESP32)
     // Configure SAR ADCn resolution

components/ulp/ulp_riscv/ulp_riscv.c

@@ -17,6 +17,7 @@
 #include "soc/rtc.h"
 #include "soc/rtc_cntl_reg.h"
 #include "soc/sens_reg.h"
+#include "hal/misc.h"
 #include "ulp_common.h"
 #include "esp_rom_sys.h"
 
@@ -157,12 +158,8 @@ esp_err_t ulp_riscv_load_binary(const uint8_t* program_binary, size_t program_si
     uint8_t* base = (uint8_t*) RTC_SLOW_MEM;
 
     //Start by clearing memory reserved with zeros, this will also will initialize the bss:
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wstringop-overflow"
-#pragma GCC diagnostic ignored "-Warray-bounds"
-    memset(base, 0, CONFIG_ULP_COPROC_RESERVE_MEM);
-    memcpy(base, program_binary, program_size_bytes);
-#pragma GCC diagnostic pop
+    hal_memset(base, 0, CONFIG_ULP_COPROC_RESERVE_MEM);
+    hal_memcpy(base, program_binary, program_size_bytes);
 
     return ESP_OK;
 }

tools/ci/check_copyright_ignore.txt

@@ -697,7 +697,6 @@ components/hal/include/hal/usb_types_private.h
 components/hal/include/hal/wdt_types.h
 components/hal/ledc_hal_iram.c
 components/hal/mpu_hal.c
-components/hal/platform_port/include/hal/misc.h
 components/hal/rtc_io_hal.c
 components/hal/sha_hal.c
 components/hal/spi_flash_encrypt_hal_iram.c