[GPU] Fix coverity issues

Author: jade-cho

src/plugins/intel_gpu/src/graph/common_utils/jit_term.hpp

@@ -213,7 +213,9 @@ inline JitTerm operator/(const JitTerm& lhs, const JitTerm& rhs) {
         return lhs;
     }
     if (is_number(lhs) && is_number(rhs)) {
-        return JitTerm{std::to_string(as_number<int64_t>(lhs) / as_number<int64_t>(rhs))};
+        auto rhs_val = as_number<int64_t>(rhs);
+        OPENVINO_ASSERT(rhs_val != 0, "Division by zero detected in operator/");
+        return JitTerm{std::to_string(as_number<int64_t>(lhs) / rhs_val)};
     }
     return JitTerm{"(" + lhs.str() + " / " + rhs.str() + ")"};
 }
@@ -224,7 +226,9 @@ inline JitTerm operator%(const JitTerm& lhs, const JitTerm& rhs) {
     }
 
     if (is_number(lhs) && is_number(rhs)) {
-        return JitTerm{std::to_string(as_number<int64_t>(lhs) % as_number<int64_t>(rhs))};
+        auto rhs_val = as_number<int64_t>(rhs);
+        OPENVINO_ASSERT(rhs_val != 0, "Modulo by zero detected in operator%");
+        return JitTerm{std::to_string(as_number<int64_t>(lhs) % rhs_val)};
     }
 
     return JitTerm{"(" + lhs.str() + " % " + rhs.str() + ")"};

src/plugins/intel_gpu/src/graph/graph_optimizer/prepare_buffer_fusing.cpp

@@ -781,6 +781,8 @@ void crop_in_place_optimization::update_in_place_crop_padding_simple_data_format
                 std::vector<ov::Dimension::value_type> reshape_upper_sizes(output_rank, 0);
                 padding::DynamicDimsMask reshape_dyn_pad_mask;
 
+                OPENVINO_ASSERT(reshape_axis >= 0 && static_cast<size_t>(reshape_axis) < output_rank, "[GPU] Calculated reshape_axis is out of range.");
+
                 reshape_lower_sizes[reshape_axis] = lower_sizes[crop_axis];
                 reshape_upper_sizes[reshape_axis] = upper_sizes[crop_axis];
                 reshape_dyn_pad_mask[reshape_axis] = 1;

src/plugins/intel_gpu/src/graph/impls/ocl/convolution.cpp

@@ -173,9 +173,12 @@ struct convolution_impl : typed_primitive_impl_ocl<convolution> {
                 && cp.weights.X().v == 1 && cp.weights.Y().v > 1
                 && !(cp.groups == cp.inputs[0].Feature().v && cp.inputs[0].Feature().v == cp.outputs[0].Feature().v)) {
                 auto can_swap = [](const kernel_selector::Tensor::DataTensor& dt) -> bool {
-                    auto x_channel_idx = static_cast<uint32_t>(kernel_selector::Tensor::DataTensor::Channelndex(dt.GetLayout(),
-                                                    kernel_selector::Tensor::DataChannelName::X));
-                    auto x_axis_dim = dt.GetDims()[x_channel_idx];
+                    auto x_channel_idx = kernel_selector::Tensor::DataTensor::Channelndex(dt.GetLayout(),
+                                                                                        kernel_selector::Tensor::DataChannelName::X);
+                    if (x_channel_idx < 0) {
+                        return false;
+                    }
+                    auto x_axis_dim = dt.GetDims()[static_cast<size_t>(x_channel_idx)];
                     return (x_axis_dim.pad.Total() == 0 && x_axis_dim.v == 1);
                 };
 

src/plugins/intel_gpu/src/kernel_selector/kernels/concatenation/concatenation_kernel_base.cpp

@@ -182,8 +182,9 @@ KernelsData ConcatenationKernelBase::GetCommonKernelsData(const Params& params)
         s.v.u32 = lastOffset;
         kernel.params.scalars.push_back(s);
         kernel.params.arguments.push_back({ArgumentDescriptor::Types::SCALAR, 0});
-        size_t concatChannelIndex = (size_t)DataTensor::Channelndex(orgParams.inputs[i].GetLayout(), GetConcatChannel(orgParams));
-        lastOffset += (uint32_t)input.GetDims()[concatChannelIndex].v;
+        auto concatChannelIndex = DataTensor::Channelndex(orgParams.inputs[i].GetLayout(), GetConcatChannel(orgParams));
+        OPENVINO_ASSERT(concatChannelIndex > -1, "[GPU] Invalid concatenation channel index found.");
+        lastOffset += (uint32_t)input.GetDims()[static_cast<size_t>(concatChannelIndex)].v;
     }
 
     return {kd};

src/plugins/intel_gpu/src/plugin/sync_infer_request.cpp

@@ -718,6 +718,7 @@ std::vector<cldnn::event::ptr> SyncInferRequest::prepare_batched_input(size_t in
             cldnn::mem_lock<uint8_t> dst_lock(merged_memory, stream);
             for (size_t i = 0; i < user_tensors.size(); i++) {
                 auto input_tensor = std::dynamic_pointer_cast<RemoteTensorImpl>(user_tensors[i]._ptr);
+                OPENVINO_ASSERT(input_tensor != nullptr, "[GPU] Failed to cast user tensor to RemoteTensorImpl");
                 cldnn::mem_lock<uint8_t> src_lock(input_tensor->get_memory(), stream);
                 std::memcpy(dst_lock.data() + i * input_tensor->get_byte_size(), src_lock.data(), input_tensor->get_byte_size());
             }