gbe_bin_generator: fix the incorrect type of cl_internal_built_in_kernel_str_size.

We should define it as size_t.

v2:
correct some extern definitions in cl_mem.c.

Signed-off-by: Zhigang Gong <zhigang.gong@intel.com>
Reviewed-by: "Luo, Xionghu" <xionghu.luo@intel.com>

3 files changed, 29 insertions, 28 deletions

diff --git a/backend/src/gbe_bin_generater.cpp b/backend/src/gbe_bin_generater.cpp
index 26276739..925ba930 100644
--- a/backend/src/gbe_bin_generater.cpp
+++ b/backend/src/gbe_bin_generater.cpp
@@ -177,6 +177,7 @@ void program_build_instance::serialize_program(void) throw(int)
       if (last_slash != string::npos &&  last_dot != string::npos)
         array_name = bin_path.substr(last_slash + 1, last_dot - 1 - last_slash);
 
+      ofs << "#include <stddef.h>" << "\n";
       ofs << "char " << array_name << "[] = {" << "\n";
 
       sz = gbe_prog->serializeToBin(oss);
@@ -194,7 +195,7 @@ void program_build_instance::serialize_program(void) throw(int)
       ofs << "};\n";
 
       string array_size = array_name + "_size";
-      ofs << "int " << array_size << " = " << sz << ";" << "\n";
+      ofs << "size_t " << array_size << " = " << sz << ";" << "\n";
     } else {
       OUTF_UPDATE_SZ(header);
       OUTF_UPDATE_SZ(header);
diff --git a/src/cl_mem.c b/src/cl_mem.c
index 05ca9f1b..ff128af4 100644
--- a/src/cl_mem.c
+++ b/src/cl_mem.c
@@ -1077,7 +1077,7 @@ cl_mem_copy(cl_command_queue queue, cl_mem src_buf, cl_mem dst_buf,
   /* All 16 bytes aligned, fast and easy one. */
   if((cb % 16 == 0) && (src_offset % 16 == 0) && (dst_offset % 16 == 0)) {
     extern char cl_internal_copy_buf_align16_str[];
-    extern int cl_internal_copy_buf_align16_str_size;
+    extern size_t cl_internal_copy_buf_align16_str_size;
 
     ker = cl_context_get_static_kernel_from_bin(queue->ctx, CL_ENQUEUE_COPY_BUFFER_ALIGN16,
              cl_internal_copy_buf_align16_str, (size_t)cl_internal_copy_buf_align16_str_size, NULL);
@@ -1085,7 +1085,7 @@ cl_mem_copy(cl_command_queue queue, cl_mem src_buf, cl_mem dst_buf,
     aligned = 1;
   } else if ((cb % 4 == 0) && (src_offset % 4 == 0) && (dst_offset % 4 == 0)) { /* all Dword aligned.*/
     extern char cl_internal_copy_buf_align4_str[];
-    extern int cl_internal_copy_buf_align4_str_size;
+    extern size_t cl_internal_copy_buf_align4_str_size;
 
     ker = cl_context_get_static_kernel_from_bin(queue->ctx, CL_ENQUEUE_COPY_BUFFER_ALIGN4,
              cl_internal_copy_buf_align4_str, (size_t)cl_internal_copy_buf_align4_str_size, NULL);
@@ -1132,7 +1132,7 @@ cl_mem_copy(cl_command_queue queue, cl_mem src_buf, cl_mem dst_buf,
     /* Src and dst has the same unaligned offset, just handle the
        header and tail. */
     extern char cl_internal_copy_buf_unalign_same_offset_str[];
-    extern int cl_internal_copy_buf_unalign_same_offset_str_size;
+    extern size_t cl_internal_copy_buf_unalign_same_offset_str_size;
 
     ker = cl_context_get_static_kernel_from_bin(queue->ctx, CL_ENQUEUE_COPY_BUFFER_UNALIGN_SAME_OFFSET,
              cl_internal_copy_buf_unalign_same_offset_str,
@@ -1155,7 +1155,7 @@ cl_mem_copy(cl_command_queue queue, cl_mem src_buf, cl_mem dst_buf,
   /* Dst's offset < Src's offset, so one dst dword need two sequential src dwords to fill it. */
   if (dst_offset % 4 < src_offset % 4) {
     extern char cl_internal_copy_buf_unalign_dst_offset_str[];
-    extern int cl_internal_copy_buf_unalign_dst_offset_str_size;
+    extern size_t cl_internal_copy_buf_unalign_dst_offset_str_size;
 
     int align_diff = src_offset % 4 - dst_offset % 4;
     unsigned int dw_mask = masks[align_diff];
@@ -1184,7 +1184,7 @@ cl_mem_copy(cl_command_queue queue, cl_mem src_buf, cl_mem dst_buf,
   /* Dst's offset > Src's offset, so one dst dword need two sequential src - and src to fill it. */
   if (dst_offset % 4 > src_offset % 4) {
     extern char cl_internal_copy_buf_unalign_src_offset_str[];
-    extern int cl_internal_copy_buf_unalign_src_offset_str_size;
+    extern size_t cl_internal_copy_buf_unalign_src_offset_str_size;
 
     int align_diff = dst_offset % 4 - src_offset % 4;
     unsigned int dw_mask = masks[4 - align_diff];
@@ -1233,31 +1233,31 @@ cl_image_fill(cl_command_queue queue, const void * pattern, struct _cl_mem_image
 
   if(src_image->image_type == CL_MEM_OBJECT_IMAGE1D) {
     extern char cl_internal_fill_image_1d_str[];
-    extern int cl_internal_fill_image_1d_str_size;
+    extern size_t cl_internal_fill_image_1d_str_size;
 
     ker = cl_context_get_static_kernel_from_bin(queue->ctx, CL_ENQUEUE_FILL_IMAGE_1D,
         cl_internal_fill_image_1d_str, (size_t)cl_internal_fill_image_1d_str_size, NULL);
   }else if(src_image->image_type == CL_MEM_OBJECT_IMAGE1D_ARRAY) {
     extern char cl_internal_fill_image_1d_array_str[];
-    extern int cl_internal_fill_image_1d_array_str_size;
+    extern size_t cl_internal_fill_image_1d_array_str_size;
 
     ker = cl_context_get_static_kernel_from_bin(queue->ctx, CL_ENQUEUE_FILL_IMAGE_1D_ARRAY,
         cl_internal_fill_image_1d_array_str, (size_t)cl_internal_fill_image_1d_array_str_size, NULL);
   }else if(src_image->image_type == CL_MEM_OBJECT_IMAGE2D) {
     extern char cl_internal_fill_image_2d_str[];
-    extern int cl_internal_fill_image_2d_str_size;
+    extern size_t cl_internal_fill_image_2d_str_size;
 
     ker = cl_context_get_static_kernel_from_bin(queue->ctx, CL_ENQUEUE_FILL_IMAGE_2D,
         cl_internal_fill_image_2d_str, (size_t)cl_internal_fill_image_2d_str_size, NULL);
   }else if(src_image->image_type == CL_MEM_OBJECT_IMAGE2D_ARRAY) {
     extern char cl_internal_fill_image_2d_array_str[];
-    extern int cl_internal_fill_image_2d_array_str_size;
+    extern size_t cl_internal_fill_image_2d_array_str_size;
 
     ker = cl_context_get_static_kernel_from_bin(queue->ctx, CL_ENQUEUE_FILL_IMAGE_2D_ARRAY,
         cl_internal_fill_image_2d_array_str, (size_t)cl_internal_fill_image_2d_array_str_size, NULL);
   }else if(src_image->image_type == CL_MEM_OBJECT_IMAGE3D) {
     extern char cl_internal_fill_image_3d_str[];
-    extern int cl_internal_fill_image_3d_str_size;
+    extern size_t cl_internal_fill_image_3d_str_size;
 
     ker = cl_context_get_static_kernel_from_bin(queue->ctx, CL_ENQUEUE_FILL_IMAGE_3D,
         cl_internal_fill_image_3d_str, (size_t)cl_internal_fill_image_3d_str_size, NULL);
@@ -1304,7 +1304,7 @@ cl_mem_fill(cl_command_queue queue, const void * pattern, size_t pattern_size,
     /* 128 is according to pattern of double16, but double works not very
        well on some platform. We use two float16 to handle this. */
     extern char cl_internal_fill_buf_align128_str[];
-    extern int cl_internal_fill_buf_align128_str_size;
+    extern size_t cl_internal_fill_buf_align128_str_size;
 
     ker = cl_context_get_static_kernel_from_bin(queue->ctx, CL_ENQUEUE_FILL_BUFFER_ALIGN128,
                cl_internal_fill_buf_align128_str, (size_t)cl_internal_fill_buf_align128_str_size, NULL);
@@ -1314,14 +1314,14 @@ cl_mem_fill(cl_command_queue queue, const void * pattern, size_t pattern_size,
     size = size / 2;
   } else if (pattern_size % 8 == 0) { /* Handle the 8 16 32 64 cases here. */
     extern char cl_internal_fill_buf_align8_str[];
-    extern int cl_internal_fill_buf_align8_str_size;
+    extern size_t cl_internal_fill_buf_align8_str_size;
     int order = ffs(pattern_size / 8) - 1;
 
     ker = cl_context_get_static_kernel_from_bin(queue->ctx, CL_ENQUEUE_FILL_BUFFER_ALIGN8_8 + order,
                cl_internal_fill_buf_align8_str, (size_t)cl_internal_fill_buf_align8_str_size, NULL);
   } else if (pattern_size == 4) {
     extern char cl_internal_fill_buf_align4_str[];
-    extern int cl_internal_fill_buf_align4_str_size;
+    extern size_t cl_internal_fill_buf_align4_str_size;
 
     ker = cl_context_get_static_kernel_from_bin(queue->ctx, CL_ENQUEUE_FILL_BUFFER_ALIGN4,
                cl_internal_fill_buf_align4_str, (size_t)cl_internal_fill_buf_align4_str_size, NULL);
@@ -1330,7 +1330,7 @@ cl_mem_fill(cl_command_queue queue, const void * pattern, size_t pattern_size,
        the pattern with the pattern duplication fill in. */
     assert(pattern_size == 1 || pattern_size == 2);
     extern char cl_internal_fill_buf_align4_str[];
-    extern int cl_internal_fill_buf_align4_str_size;
+    extern size_t cl_internal_fill_buf_align4_str_size;
 
     if (pattern_size == 2) {
       memcpy(pattern_comb, pattern, sizeof(char)*2);
@@ -1349,12 +1349,12 @@ cl_mem_fill(cl_command_queue queue, const void * pattern, size_t pattern_size,
   //functions. This depend on the usage but now we just use aligned 1 and 2.
   else if (pattern_size == 2) {
     extern char cl_internal_fill_buf_align2_str[];
-    extern int cl_internal_fill_buf_align2_str_size;
+    extern size_t cl_internal_fill_buf_align2_str_size;
     ker = cl_context_get_static_kernel_from_bin(queue->ctx, CL_ENQUEUE_FILL_BUFFER_ALIGN2,
                cl_internal_fill_buf_align2_str, (size_t)cl_internal_fill_buf_align2_str_size, NULL);
   } else if (pattern_size == 1) {
     extern char cl_internal_fill_buf_unalign_str[];
-    extern int cl_internal_fill_buf_unalign_str_size;
+    extern size_t cl_internal_fill_buf_unalign_str_size;
     ker = cl_context_get_static_kernel_from_bin(queue->ctx, CL_ENQUEUE_FILL_BUFFER_UNALIGN,
                cl_internal_fill_buf_unalign_str, (size_t)cl_internal_fill_buf_unalign_str_size, NULL);
   } else
@@ -1406,7 +1406,7 @@ cl_mem_copy_buffer_rect(cl_command_queue queue, cl_mem src_buf, cl_mem dst_buf,
 
   /* setup the kernel and run. */
   extern char cl_internal_copy_buf_rect_str[];
-  extern int cl_internal_copy_buf_rect_str_size;
+  extern size_t cl_internal_copy_buf_rect_str_size;
 
   ker = cl_context_get_static_kernel_from_bin(queue->ctx, CL_ENQUEUE_COPY_BUFFER_RECT,
       cl_internal_copy_buf_rect_str, (size_t)cl_internal_copy_buf_rect_str_size, NULL);
@@ -1478,7 +1478,7 @@ cl_mem_kernel_copy_image(cl_command_queue queue, struct _cl_mem_image* src_image
   if(src_image->image_type == CL_MEM_OBJECT_IMAGE1D) {
     if(dst_image->image_type == CL_MEM_OBJECT_IMAGE1D) {
       extern char cl_internal_copy_image_1d_to_1d_str[];
-      extern int cl_internal_copy_image_1d_to_1d_str_size;
+      extern size_t cl_internal_copy_image_1d_to_1d_str_size;
 
       ker = cl_context_get_static_kernel_from_bin(queue->ctx, CL_ENQUEUE_COPY_IMAGE_1D_TO_1D,
           cl_internal_copy_image_1d_to_1d_str, (size_t)cl_internal_copy_image_1d_to_1d_str_size, NULL);
@@ -1486,13 +1486,13 @@ cl_mem_kernel_copy_image(cl_command_queue queue, struct _cl_mem_image* src_image
   } else if(src_image->image_type == CL_MEM_OBJECT_IMAGE2D) {
     if(dst_image->image_type == CL_MEM_OBJECT_IMAGE2D) {
       extern char cl_internal_copy_image_2d_to_2d_str[];
-      extern int cl_internal_copy_image_2d_to_2d_str_size;
+      extern size_t cl_internal_copy_image_2d_to_2d_str_size;
 
       ker = cl_context_get_static_kernel_from_bin(queue->ctx, CL_ENQUEUE_COPY_IMAGE_2D_TO_2D,
           cl_internal_copy_image_2d_to_2d_str, (size_t)cl_internal_copy_image_2d_to_2d_str_size, NULL);
     } else if(dst_image->image_type == CL_MEM_OBJECT_IMAGE3D) {
       extern char cl_internal_copy_image_2d_to_3d_str[];
-      extern int cl_internal_copy_image_2d_to_3d_str_size;
+      extern size_t cl_internal_copy_image_2d_to_3d_str_size;
 
       ker = cl_context_get_static_kernel_from_bin(queue->ctx, CL_ENQUEUE_COPY_IMAGE_2D_TO_3D,
           cl_internal_copy_image_2d_to_3d_str, (size_t)cl_internal_copy_image_2d_to_3d_str_size, NULL);
@@ -1522,13 +1522,13 @@ cl_mem_kernel_copy_image(cl_command_queue queue, struct _cl_mem_image* src_image
   } else if(src_image->image_type == CL_MEM_OBJECT_IMAGE3D) {
     if(dst_image->image_type == CL_MEM_OBJECT_IMAGE2D) {
       extern char cl_internal_copy_image_3d_to_2d_str[];
-      extern int cl_internal_copy_image_3d_to_2d_str_size;
+      extern size_t cl_internal_copy_image_3d_to_2d_str_size;
 
       ker = cl_context_get_static_kernel_from_bin(queue->ctx, CL_ENQUEUE_COPY_IMAGE_3D_TO_2D,
           cl_internal_copy_image_3d_to_2d_str, (size_t)cl_internal_copy_image_3d_to_2d_str_size, NULL);
     } else if(dst_image->image_type == CL_MEM_OBJECT_IMAGE3D) {
       extern char cl_internal_copy_image_3d_to_3d_str[];
-      extern int cl_internal_copy_image_3d_to_3d_str_size;
+      extern size_t cl_internal_copy_image_3d_to_3d_str_size;
 
       ker = cl_context_get_static_kernel_from_bin(queue->ctx, CL_ENQUEUE_COPY_IMAGE_3D_TO_3D,
           cl_internal_copy_image_3d_to_3d_str, (size_t)cl_internal_copy_image_3d_to_3d_str_size, NULL);
@@ -1600,13 +1600,13 @@ cl_mem_copy_image_to_buffer(cl_command_queue queue, struct _cl_mem_image* image,
   /* setup the kernel and run. */
   if(image->image_type == CL_MEM_OBJECT_IMAGE2D) {
       extern char cl_internal_copy_image_2d_to_buffer_str[];
-      extern int cl_internal_copy_image_2d_to_buffer_str_size;
+      extern size_t cl_internal_copy_image_2d_to_buffer_str_size;
 
       ker = cl_context_get_static_kernel_from_bin(queue->ctx, CL_ENQUEUE_COPY_IMAGE_2D_TO_BUFFER,
           cl_internal_copy_image_2d_to_buffer_str, (size_t)cl_internal_copy_image_2d_to_buffer_str_size, NULL);
   }else if(image->image_type == CL_MEM_OBJECT_IMAGE3D) {
     extern char cl_internal_copy_image_3d_to_buffer_str[];
-    extern int cl_internal_copy_image_3d_to_buffer_str_size;
+    extern size_t cl_internal_copy_image_3d_to_buffer_str_size;
 
     ker = cl_context_get_static_kernel_from_bin(queue->ctx, CL_ENQUEUE_COPY_IMAGE_3D_TO_BUFFER,
           cl_internal_copy_image_3d_to_buffer_str, (size_t)cl_internal_copy_image_3d_to_buffer_str_size, NULL);
@@ -1674,13 +1674,13 @@ cl_mem_copy_buffer_to_image(cl_command_queue queue, cl_mem buffer, struct _cl_me
   /* setup the kernel and run. */
   if(image->image_type == CL_MEM_OBJECT_IMAGE2D) {
       extern char cl_internal_copy_buffer_to_image_2d_str[];
-      extern int cl_internal_copy_buffer_to_image_2d_str_size;
+      extern size_t cl_internal_copy_buffer_to_image_2d_str_size;
 
       ker = cl_context_get_static_kernel_from_bin(queue->ctx, CL_ENQUEUE_COPY_BUFFER_TO_IMAGE_2D,
           cl_internal_copy_buffer_to_image_2d_str, (size_t)cl_internal_copy_buffer_to_image_2d_str_size, NULL);
   }else if(image->image_type == CL_MEM_OBJECT_IMAGE3D) {
       extern char cl_internal_copy_buffer_to_image_3d_str[];
-      extern int cl_internal_copy_buffer_to_image_3d_str_size;
+      extern size_t cl_internal_copy_buffer_to_image_3d_str_size;
 
       ker = cl_context_get_static_kernel_from_bin(queue->ctx, CL_ENQUEUE_COPY_BUFFER_TO_IMAGE_3D,
           cl_internal_copy_buffer_to_image_3d_str, (size_t)cl_internal_copy_buffer_to_image_3d_str_size, NULL);
diff --git a/src/cl_program.c b/src/cl_program.c
index 7888a8fc..d7e9ae7b 100644
--- a/src/cl_program.c
+++ b/src/cl_program.c
@@ -268,7 +268,7 @@ cl_program_create_with_built_in_kernles(cl_context     ctx,
   INVALID_DEVICE_IF (devices[0] != ctx->device);
 
   extern char cl_internal_built_in_kernel_str[];
-  extern int cl_internal_built_in_kernel_str_size;
+  extern size_t cl_internal_built_in_kernel_str_size;
   char* p_built_in_kernel_str =cl_internal_built_in_kernel_str;
   cl_int binary_status = CL_SUCCESS;