core system: Fix warnings in compilation when assertions are disabled

Adds a CI config for hello world that sets this, to catch future regressions

Author: projectgus

components/bootloader_support/src/idf/bootloader_sha.c

@@ -39,6 +39,7 @@ void bootloader_sha256_data(bootloader_sha256_handle_t handle, const void *data,
     mbedtls_sha256_context *ctx = (mbedtls_sha256_context *)handle;
     int ret = mbedtls_sha256_update_ret(ctx, data, data_len);
     assert(ret == 0);
+    (void)ret;
 }
 
 void bootloader_sha256_finish(bootloader_sha256_handle_t handle, uint8_t *digest)
@@ -48,6 +49,7 @@ void bootloader_sha256_finish(bootloader_sha256_handle_t handle, uint8_t *digest
     if (digest != NULL) {
         int ret = mbedtls_sha256_finish_ret(ctx, digest);
         assert(ret == 0);
+        (void)ret;
     }
     mbedtls_sha256_free(ctx);
     free(handle);

components/bt/CMakeLists.txt

@@ -599,3 +599,13 @@ if(CONFIG_BT_ENABLED)
         target_link_libraries(${COMPONENT_LIB} PUBLIC btdm_app btbb)
     endif()
 endif()
+
+if(CONFIG_BT_NIMBLE_MESH)
+    set_source_files_properties("host/nimble/nimble/nimble/host/mesh/src/net.c"
+        PROPERTIES COMPILE_FLAGS -Wno-type-limits)
+endif()
+
+if(CONFIG_COMPILER_OPTIMIZATION_ASSERTIONS_DISABLE AND CONFIG_BT_NIMBLE_ENABLED)
+    # some variables in NimBLE are only used by asserts
+    target_compile_options(${COMPONENT_LIB} PRIVATE -Wno-unused-but-set-variable -Wno-unused-variable)
+endif()

components/bt/common/osi/hash_map.c

@@ -144,6 +144,7 @@ bool hash_map_set(hash_map_t *hash_map, const void *key, void *data)
         // Calls hash_map callback to delete the hash_map_entry.
         bool rc = list_remove(hash_bucket_list, hash_map_entry);
         assert(rc == true);
+        (void)rc;
     } else {
         hash_map->hash_size++;
     }

components/bt/controller/esp32/bt.c

@@ -1309,7 +1309,8 @@ esp_err_t esp_bt_controller_init(esp_bt_controller_config_t *cfg)
     btdm_lpclk_sel = BTDM_LPCLK_SEL_XTAL; // set default value
 #endif
 
-    bool select_src_ret, set_div_ret;
+    bool select_src_ret __attribute__((unused));
+    bool set_div_ret __attribute__((unused));
     if (btdm_lpclk_sel == BTDM_LPCLK_SEL_XTAL) {
         select_src_ret = btdm_lpclk_select_src(BTDM_LPCLK_SEL_XTAL);
         set_div_ret = btdm_lpclk_set_div(rtc_clk_xtal_freq_get() * 2 - 1);

components/bt/controller/esp32c3/bt.c

@@ -1050,7 +1050,8 @@ esp_err_t esp_bt_controller_init(esp_bt_controller_config_t *cfg)
         s_lp_cntl.lpclk_sel = BTDM_LPCLK_SEL_XTAL; // set default value
 #endif
 
-        bool select_src_ret, set_div_ret;
+        bool select_src_ret __attribute__((unused));
+        bool set_div_ret __attribute__((unused));
         if (s_lp_cntl.lpclk_sel == BTDM_LPCLK_SEL_XTAL) {
             select_src_ret = btdm_lpclk_select_src(BTDM_LPCLK_SEL_XTAL);
             set_div_ret = btdm_lpclk_set_div(rtc_clk_xtal_freq_get() * 2);

components/bt/controller/esp32s3/bt.c

@@ -988,8 +988,8 @@ esp_err_t esp_bt_controller_init(esp_bt_controller_config_t *cfg)
             cfg->sleep_clock = ESP_BT_SLEEP_CLOCK_FPGA_32K;
             ESP_LOGW(BTDM_LOG_TAG, "%s sleep clock overwrite on FPGA", __func__);
         #endif
-            bool select_src_ret = false;
-            bool set_div_ret = false;
+            bool select_src_ret __attribute__((unused));
+            bool set_div_ret __attribute__((unused));
             if (cfg->sleep_clock == ESP_BT_SLEEP_CLOCK_MAIN_XTAL) {
                 select_src_ret = btdm_lpclk_select_src(BTDM_LPCLK_SEL_XTAL);
                 set_div_ret = btdm_lpclk_set_div(rtc_clk_xtal_freq_get() * 2);

components/bt/host/bluedroid/hci/hci_packet_parser.c

@@ -227,19 +227,19 @@ static uint8_t *read_command_complete_header(
     uint8_t *stream = response->data + response->offset;
 
     // Read the event header
-    uint8_t event_code;
-    uint8_t parameter_length;
+    uint8_t event_code __attribute__((unused));
+    uint8_t parameter_length __attribute__((unused));
     STREAM_TO_UINT8(event_code, stream);
     STREAM_TO_UINT8(parameter_length, stream);
 
-    const size_t parameter_bytes_we_read_here = 4;
+    const size_t parameter_bytes_we_read_here  __attribute__((unused)) = 4;
 
     // Check the event header values against what we expect
     assert(event_code == HCI_COMMAND_COMPLETE_EVT);
     assert(parameter_length >= (parameter_bytes_we_read_here + minimum_bytes_after));
 
     // Read the command complete header
-    command_opcode_t opcode;
+    command_opcode_t opcode __attribute__((unused));
     uint8_t status;
     STREAM_SKIP_UINT8(stream); // skip the number of hci command packets field
     STREAM_TO_UINT16(opcode, stream);

components/bt/host/bluedroid/hci/packet_fragmenter.c

@@ -141,7 +141,7 @@ static void reassemble_and_dispatch(BT_HDR *packet)
         uint8_t *stream = packet->data + packet->offset;
         uint16_t handle;
         uint16_t l2cap_length;
-        uint16_t acl_length;
+        uint16_t acl_length __attribute__((unused));
 
         STREAM_TO_UINT16(handle, stream);
         STREAM_TO_UINT16(acl_length, stream);

components/cxx/cxx_guards.cpp

@@ -82,6 +82,7 @@ static void wait_for_guard_obj(guard_t* g)
     do {
         auto result = xSemaphoreGive(s_static_init_mutex);
         assert(result);
+        static_cast<void>(result);
         /* Task may be preempted here, but this isn't a problem,
          * as the semaphore will be given exactly the s_static_init_waiting_count
          * number of times; eventually the current task will execute next statement,
@@ -140,6 +141,7 @@ extern "C" int __cxa_guard_acquire(__guard* pg)
          */
         auto result = xSemaphoreTake(s_static_init_mutex, portMAX_DELAY);
         assert(result);
+        static_cast<void>(result);
         if (g->pending) {
             /* Another task is doing initialization at the moment; wait until it calls
              * __cxa_guard_release or __cxa_guard_abort
@@ -168,6 +170,7 @@ extern "C" int __cxa_guard_acquire(__guard* pg)
     if (scheduler_started) {
         auto result = xSemaphoreGive(s_static_init_mutex);
         assert(result);
+        static_cast<void>(result);
     }
     return ret;
 }
@@ -179,6 +182,7 @@ extern "C" void __cxa_guard_release(__guard* pg)
     if (scheduler_started) {
         auto result = xSemaphoreTake(s_static_init_mutex, portMAX_DELAY);
         assert(result);
+        static_cast<void>(result);
     }
     assert(g->pending && "tried to release a guard which wasn't acquired");
     g->pending = 0;
@@ -189,6 +193,7 @@ extern "C" void __cxa_guard_release(__guard* pg)
         signal_waiting_tasks();
         auto result = xSemaphoreGive(s_static_init_mutex);
         assert(result);
+        static_cast<void>(result);
     }
 }
 
@@ -199,6 +204,7 @@ extern "C" void __cxa_guard_abort(__guard* pg)
     if (scheduler_started) {
         auto result = xSemaphoreTake(s_static_init_mutex, portMAX_DELAY);
         assert(result);
+        static_cast<void>(result);
     }
     assert(!g->ready && "tried to abort a guard which is ready");
     assert(g->pending && "tried to release a guard which is not acquired");
@@ -208,6 +214,7 @@ extern "C" void __cxa_guard_abort(__guard* pg)
         signal_waiting_tasks();
         auto result = xSemaphoreGive(s_static_init_mutex);
         assert(result);
+        static_cast<void>(result);
     }
 }
 

components/driver/sdio_slave.c

@@ -375,6 +375,7 @@ void sdio_slave_deinit(void)
     }
     esp_err_t ret = esp_intr_free(context.intr_handle);
     assert(ret==ESP_OK);
+    (void)ret;
     context.intr_handle = NULL;
     deinit_context();
 }
@@ -532,7 +533,7 @@ static void sdio_intr_send(void* arg)
 
     uint32_t returned_cnt;
     if (sdio_slave_hal_send_eof_happened(context.hal)) {
-        portBASE_TYPE ret = pdTRUE;
+        portBASE_TYPE ret __attribute__((unused));
 
         esp_err_t err;
         while (1) {
@@ -549,7 +550,7 @@ static void sdio_intr_send(void* arg)
         }
         //get_next_finished_arg returns the total amount of returned descs.
         for(size_t i = 0; i < returned_cnt; i++) {
-            portBASE_TYPE ret = xSemaphoreGiveFromISR(context.remain_cnt, &yield);
+            ret = xSemaphoreGiveFromISR(context.remain_cnt, &yield);
             assert(ret == pdTRUE);
         }
     }
@@ -603,16 +604,17 @@ esp_err_t sdio_slave_transmit(uint8_t* addr, size_t len)
 static esp_err_t send_flush_data(void)
 {
     esp_err_t err;
+    portBASE_TYPE ret __attribute__((unused));
 
     while (1) {
         void *finished_arg;
         uint32_t return_cnt = 0;
         err = sdio_slave_hal_send_flush_next_buffer(context.hal, &finished_arg, &return_cnt);
         if (err == ESP_OK) {
-            portBASE_TYPE ret = xQueueSend(context.ret_queue, &finished_arg, portMAX_DELAY);
+            ret = xQueueSend(context.ret_queue, &finished_arg, portMAX_DELAY);
             assert(ret == pdTRUE);
             for (size_t i = 0; i < return_cnt; i++) {
-                portBASE_TYPE ret = xSemaphoreGive(context.remain_cnt);
+                ret = xSemaphoreGive(context.remain_cnt);
                 assert(ret == pdTRUE);
             }
         } else {