misc: fix warnings with -Wall and -Wextra

RABijl · RABijl · commit 4a95e8aed589 · 2024-11-05T10:29:56.000+02:00
Some things being fixed:
* signed compare warnings
* set but unused variables
* bracket warnings
diff --git a/examples/example1/example1.c b/examples/example1/example1.c
@@ -49,7 +49,8 @@ main (int argc, char **argv)
   cl_float4 *srcA = NULL;
   cl_float4 *srcB = NULL;
   cl_float *dst = NULL;
-  int i, err, spirv, poclbin;
+  int err, spirv, poclbin;
+  cl_uint i;
 
   cl_context context = NULL;
   cl_platform_id platform = NULL;
diff --git a/lib/CL/clEnqueueUnmapMemObject.c b/lib/CL/clEnqueueUnmapMemObject.c
@@ -97,6 +97,9 @@ POname(clEnqueueUnmapMemObject)(cl_command_queue command_queue,
 
   /* Release the "mapping reference" which keeps the buffer alive until the
      mapping is on. The command execution should also retain/release. */
+#ifdef __GNUC__
+  __attribute__ ((unused))
+#endif
   int newrefc;
   POCL_RELEASE_OBJECT (memobj, newrefc);
 
diff --git a/lib/CL/clSetKernelArg.c b/lib/CL/clSetKernelArg.c
@@ -143,6 +143,8 @@ pocl_verify_dbk_kernel_args (cl_mem buf,
         POCL_RETURN_ERROR_ON (1, CL_INVALID_ARG_INDEX,
                               "invalid arg index to "
                               "POCL_CDBI_DBK_EXP_GEMM");
+        /* not needed but GCC thinks this case may fall through */
+        break;
       }
     case POCL_CDBI_DBK_EXP_MATMUL:
       {
@@ -157,6 +159,8 @@ pocl_verify_dbk_kernel_args (cl_mem buf,
         POCL_RETURN_ERROR_ON (1, CL_INVALID_ARG_INDEX,
                               "invalid arg index to "
                               "POCL_CDBI_DBK_EXP_MATMUL");
+        /* not needed but GCC thinks this case may fall through */
+        break;
       }
     case POCL_CDBI_DBK_EXP_JPEG_ENCODE:
     case POCL_CDBI_DBK_EXP_JPEG_DECODE:
diff --git a/lib/CL/devices/cpu_dbk/pocl_dbk_khr_onnxrt_cpu.c b/lib/CL/devices/cpu_dbk/pocl_dbk_khr_onnxrt_cpu.c
@@ -249,7 +249,6 @@ pocl_destroy_ort_instance (onnxrt_instance_t **onnxrt)
   *onnxrt = NULL;
   free (ort);
 
-ERROR:
   return CL_SUCCESS;
 }
 
diff --git a/lib/CL/devices/remote/remote.c b/lib/CL/devices/remote/remote.c
@@ -1017,7 +1017,7 @@ pocl_remote_build_binary (cl_program program, cl_uint device_i,
 
       program->data[real_i] = pd;
       assert ((!spirv_build && program->binary_sizes[real_i] > 0)
-              || spirv_build && program->program_il_size > 0);
+              || (spirv_build && program->program_il_size > 0));
       assert ((!spirv_build && program->binaries[real_i] != NULL)
               || (spirv_build && program->program_il != NULL));
 
@@ -2736,7 +2736,7 @@ pocl_remote_set_kernel_exec_info_ext (cl_device_id dev,
     case CL_KERNEL_EXEC_INFO_SVM_PTRS:
     case CL_KERNEL_EXEC_INFO_USM_PTRS_INTEL:
       {
-        for (int i = 0; i < param_value_size / sizeof (void *); ++i)
+        for (size_t i = 0; i < param_value_size / sizeof (void *); ++i)
           {
             struct _pocl_ptr_list_node *n
                 = malloc (sizeof (struct _pocl_ptr_list_node));
diff --git a/lib/CL/pocl_binary.c b/lib/CL/pocl_binary.c
@@ -876,7 +876,7 @@ pocl_binary_get_kernels_metadata (cl_program program, unsigned device_i)
       BUFFER_READ(len, uint64_t);
       assert (len > 0);
       buffer += len;
-      assert (buffer - start <= max_len);
+      assert ((size_t) (buffer - start) <= max_len);
     }
 
   unsigned j;
diff --git a/lib/CL/pocl_builtin_kernels.c b/lib/CL/pocl_builtin_kernels.c
@@ -886,9 +886,14 @@ pocl_copy_defined_builtin_attributes (BuiltinKernelId kernel_id,
           = (cl_dbk_attributes_exp_gemm *)kernel_attributes;
         memcpy (attrs, src, sizeof (cl_dbk_attributes_exp_gemm));
         err = pocl_copy_tensor_desc_layout (&attrs->a, &src->a);
-        err = pocl_copy_tensor_desc_layout (&attrs->b, &src->b);
-        err = pocl_copy_tensor_desc_layout (&attrs->c_in, &src->c_in);
-        err = pocl_copy_tensor_desc_layout (&attrs->c_out, &src->c_out);
+        err |= pocl_copy_tensor_desc_layout(&attrs->b, &src->b);
+        err |= pocl_copy_tensor_desc_layout(&attrs->c_in, &src->c_in);
+        err |= pocl_copy_tensor_desc_layout(&attrs->c_out, &src->c_out);
+        if (err != CL_SUCCESS) {
+          POCL_MSG_WARN("Could not copy POCL_CDBI_DBK_EXP_GEMM attributes (err: %d).\n", err);
+          free(attrs);
+          return NULL;
+        }
 
         return attrs;
       }
@@ -903,9 +908,13 @@ pocl_copy_defined_builtin_attributes (BuiltinKernelId kernel_id,
         memcpy (attrs, src, sizeof (cl_dbk_attributes_exp_matmul));
 
         err = pocl_copy_tensor_desc_layout (&attrs->a, &src->a);
-        err = pocl_copy_tensor_desc_layout (&attrs->b, &src->b);
-        err = pocl_copy_tensor_desc_layout (&attrs->c, &src->c);
-
+        err |= pocl_copy_tensor_desc_layout (&attrs->b, &src->b);
+        err |= pocl_copy_tensor_desc_layout (&attrs->c, &src->c);
+        if (err != CL_SUCCESS) {
+          POCL_MSG_WARN("Could not copy POCL_CDBI_DBK_EXP_MATMUL attributes (err: %d).\n", err);
+          free(attrs);
+          return NULL;
+        }
         return attrs;
       }
     case POCL_CDBI_DBK_EXP_JPEG_ENCODE:
diff --git a/lib/CL/pocl_tensor_util.c b/lib/CL/pocl_tensor_util.c
@@ -346,9 +346,9 @@ pocl_tensor_dtype_value_equals (const cl_tensor_datatype DType,
     case CL_TENSOR_DTYPE_INT64:
       return (Value->l == longConst);
     case CL_TENSOR_DTYPE_UINT64:
-      return (Value->l == ulongConst);
+      return ((cl_ulong)Value->l == ulongConst);
     case CL_TENSOR_DTYPE_INT32:
-      return ((cl_long)Value->l == longConst);
+      return (Value->l == longConst);
     case CL_TENSOR_DTYPE_UINT32:
       return ((cl_ulong)Value->i == ulongConst);
     case CL_TENSOR_DTYPE_INT16:
diff --git a/tests/runtime/test_dbk_jpeg.c b/tests/runtime/test_dbk_jpeg.c
@@ -201,7 +201,7 @@ main (int argc, char const *argv[])
                             write_event, decode_event };
   size_t all_events_size = sizeof (all_events) / sizeof (all_events[0]);
   clWaitForEvents (all_events_size, all_events);
-  for (int i = 0; i < all_events_size; i++)
+  for (size_t i = 0; i < all_events_size; i++)
     clReleaseEvent (all_events[i]);
 
   TEST_ASSERT (jpeg_size_value > 0);
@@ -220,7 +220,7 @@ main (int argc, char const *argv[])
   clReleaseKernel (decode_kernel);
   clReleaseProgram (program);
   clReleaseContext (context);
-  for (int i = 0; i < num_devices; i++)
+  for (cl_uint i = 0; i < num_devices; i++)
     {
       clReleaseDevice (devices[i]);
       clReleaseCommandQueue (queues[i]);
diff --git a/tests/runtime/test_event_free.c b/tests/runtime/test_event_free.c
@@ -144,7 +144,7 @@ int main(int argc, char **argv)
    */
 
   if (has_img) {
-    cl_uint4 color = {0,0,0,0};
+    cl_uint4 color = {{0,0,0,0}};
     const size_t origin[] = {0, 0, 0};
     const size_t region[] = {1, 1, 1};
 
diff --git a/tests/runtime/test_fill-buffer.c b/tests/runtime/test_fill-buffer.c
@@ -107,35 +107,35 @@ main (void)
                                                    NULL, NULL));
 
               CHECK_CL_ERROR (clFinish (queue));
-              for (int i = 0; i < pattern_size * 2; i++)
+              for (int k = 0; k < pattern_size * 2; k++)
                 {
-                  if (host_buf1[i] != 1)
+                  if (host_buf1[k] != 1)
                     {
-                      printf ("Expected value at %d: 1, actual value: %d\n", i,
-                              host_buf1[i]);
+                      printf ("Expected value at %d: 1, actual value: %d\n", k,
+                              host_buf1[k]);
                       return EXIT_FAILURE;
                     }
                 }
-              for (int i = buf_size - pattern_size; i < buf_size; i++)
+              for (size_t k = buf_size - pattern_size; k < buf_size; k++)
                 {
-                  if (host_buf1[i] != 1)
+                  if (host_buf1[k] != 1)
                     {
-                      printf ("Expected value at %d: 1, actual value: %d\n", i,
-                              host_buf1[i]);
+                      printf ("Expected value at %zu: 1, actual value: %d\n",
+                              k, host_buf1[k]);
                       return EXIT_FAILURE;
                     }
                 }
-              for (int i = pattern_size * 2; i < buf_size - pattern_size;
-                   i += pattern_size)
+              for (size_t k = pattern_size * 2; k < buf_size - pattern_size;
+                   k += pattern_size)
                 {
-                  for (int j = 0; j < pattern_size; j++)
+                  for (int l = 0; l < pattern_size; l++)
                     {
-                      cl_char expected_value = *((char *)&(pattern) + j);
-                      if (host_buf1[i + j] != expected_value)
+                      cl_char expected_value = *((char *)&(pattern) + l);
+                      if (host_buf1[k + l] != expected_value)
                         {
                           printf (
-                              "Expected value at %d: %d, actual value: %d\n",
-                              i + j, expected_value, host_buf1[i + j]);
+                            "Expected value at %zu: %d, actual value: %d\n",
+                            k + l, expected_value, host_buf1[k + l]);
                           return EXIT_FAILURE;
                         }
                     }

Original file line number	Diff line number	Diff line change
`@@ -143,6 +143,8 @@ pocl_verify_dbk_kernel_args (cl_mem buf,`
`143`	`143`	`POCL_RETURN_ERROR_ON (1, CL_INVALID_ARG_INDEX,`
`144`	`144`	`"invalid arg index to "`
`145`	`145`	`"POCL_CDBI_DBK_EXP_GEMM");`
	`146`	`+ /* not needed but GCC thinks this case may fall through */`
	`147`	`+ break;`
`146`	`148`	`}`
`147`	`149`	`case POCL_CDBI_DBK_EXP_MATMUL:`
`148`	`150`	`{`
`@@ -157,6 +159,8 @@ pocl_verify_dbk_kernel_args (cl_mem buf,`
`157`	`159`	`POCL_RETURN_ERROR_ON (1, CL_INVALID_ARG_INDEX,`
`158`	`160`	`"invalid arg index to "`
`159`	`161`	`"POCL_CDBI_DBK_EXP_MATMUL");`
	`162`	`+ /* not needed but GCC thinks this case may fall through */`
	`163`	`+ break;`
`160`	`164`	`}`
`161`	`165`	`case POCL_CDBI_DBK_EXP_JPEG_ENCODE:`
`162`	`166`	`case POCL_CDBI_DBK_EXP_JPEG_DECODE:`
Original file line number	Diff line number	Diff line change
`@@ -249,7 +249,6 @@ pocl_destroy_ort_instance (onnxrt_instance_t **onnxrt)`
`249`	`249`	`*onnxrt = NULL;`
`250`	`250`	`free (ort);`
`251`	`251`
`252`		`-ERROR:`
`253`	`252`	`return CL_SUCCESS;`
`254`	`253`	`}`
`255`	`254`
Original file line number	Diff line number	Diff line change
`@@ -876,7 +876,7 @@ pocl_binary_get_kernels_metadata (cl_program program, unsigned device_i)`
`876`	`876`	`BUFFER_READ(len, uint64_t);`
`877`	`877`	`assert (len > 0);`
`878`	`878`	`buffer += len;`
`879`		`- assert (buffer - start <= max_len);`
	`879`	`+ assert ((size_t) (buffer - start) <= max_len);`
`880`	`880`	`}`
`881`	`881`
`882`	`882`	`unsigned j;`
Original file line number	Diff line number	Diff line change
`@@ -107,35 +107,35 @@ main (void)`
`107`	`107`	`NULL, NULL));`
`108`	`108`
`109`	`109`	`CHECK_CL_ERROR (clFinish (queue));`
`110`		`- for (int i = 0; i < pattern_size * 2; i++)`
	`110`	`+ for (int k = 0; k < pattern_size * 2; k++)`
`111`	`111`	`{`
`112`		`- if (host_buf1[i] != 1)`
	`112`	`+ if (host_buf1[k] != 1)`
`113`	`113`	`{`
`114`		`- printf ("Expected value at %d: 1, actual value: %d\n", i,`
`115`		`- host_buf1[i]);`
	`114`	`+ printf ("Expected value at %d: 1, actual value: %d\n", k,`
	`115`	`+ host_buf1[k]);`
`116`	`116`	`return EXIT_FAILURE;`
`117`	`117`	`}`
`118`	`118`	`}`
`119`		`- for (int i = buf_size - pattern_size; i < buf_size; i++)`
	`119`	`+ for (size_t k = buf_size - pattern_size; k < buf_size; k++)`
`120`	`120`	`{`
`121`		`- if (host_buf1[i] != 1)`
	`121`	`+ if (host_buf1[k] != 1)`
`122`	`122`	`{`
`123`		`- printf ("Expected value at %d: 1, actual value: %d\n", i,`
`124`		`- host_buf1[i]);`
	`123`	`+ printf ("Expected value at %zu: 1, actual value: %d\n",`
	`124`	`+ k, host_buf1[k]);`
`125`	`125`	`return EXIT_FAILURE;`
`126`	`126`	`}`
`127`	`127`	`}`
`128`		`- for (int i = pattern_size * 2; i < buf_size - pattern_size;`
`129`		`- i += pattern_size)`
	`128`	`+ for (size_t k = pattern_size * 2; k < buf_size - pattern_size;`
	`129`	`+ k += pattern_size)`
`130`	`130`	`{`
`131`		`- for (int j = 0; j < pattern_size; j++)`
	`131`	`+ for (int l = 0; l < pattern_size; l++)`
`132`	`132`	`{`
`133`		`- cl_char expected_value = ((char )&(pattern) + j);`
`134`		`- if (host_buf1[i + j] != expected_value)`
	`133`	`+ cl_char expected_value = ((char )&(pattern) + l);`
	`134`	`+ if (host_buf1[k + l] != expected_value)`
`135`	`135`	`{`
`136`	`136`	`printf (`
`137`		`- "Expected value at %d: %d, actual value: %d\n",`
`138`		`- i + j, expected_value, host_buf1[i + j]);`
	`137`	`+ "Expected value at %zu: %d, actual value: %d\n",`
	`138`	`+ k + l, expected_value, host_buf1[k + l]);`
`139`	`139`	`return EXIT_FAILURE;`
`140`	`140`	`}`
`141`	`141`	`}`