[slice]fix Fix a possible out-of-bounds bug with index int32 types &&… (#73468)

* [slice]fix Fix a possible out-of-bounds bug with index int32 types && slice-check

* slice-check

Author: zhanghonggeng

paddle/fluid/pybind/eager_method.cc

@@ -2033,7 +2033,17 @@ static PyObject* tensor__setitem_dygraph(TensorObject* self,
           int64_t slice_offset =
               static_cast<int64_t>(reinterpret_cast<char*>(sub_tensor.data()) -
                                    reinterpret_cast<char*>(tensor.data()));
-          AdvancedIndex ad = AdvancedIndex(transed_sub_tensor, transed_index);
+
+          std::vector<paddle::Tensor> transed_index_int64;
+          for (auto& indice : transed_index) {
+            if (indice.defined() && indice.dtype() == paddle::DataType::INT32) {
+              indice = indice.cast(paddle::DataType::INT64);  // int32 -> int64
+            }
+            transed_index_int64.push_back(indice);
+          }
+
+          AdvancedIndex ad =
+              AdvancedIndex(transed_sub_tensor, transed_index_int64);
           transed_sub_tensor =
               index_elementwise_put__ad_func(tensor,
                                              ad.indices,

paddle/phi/kernels/gpu/index_elementwise_put_grad_kernel.cu

@@ -186,25 +186,14 @@ void LaunchIndexElementwisePutGradCudaKernel(
   if (x_grad) {
     phi::Copy(dev_ctx, out_grad, dev_ctx.GetPlace(), false, x_grad);
 
-    if (index_type == phi::DataType::INT32) {
-      GPUIndexElementwisePutGradKernel<T, int>(dev_ctx,
-                                               x_indices,
-                                               input_dims,
-                                               input_strides,
-                                               index_dims,
-                                               index_strides,
-                                               slice_offset,
-                                               x_grad);
-    } else if (index_type == phi::DataType::INT64) {
-      GPUIndexElementwisePutGradKernel<T, int64_t>(dev_ctx,
-                                                   x_indices,
-                                                   input_dims,
-                                                   input_strides,
-                                                   index_dims,
-                                                   index_strides,
-                                                   slice_offset,
-                                                   x_grad);
-    }
+    GPUIndexElementwisePutGradKernel<T, int64_t>(dev_ctx,
+                                                 x_indices,
+                                                 input_dims,
+                                                 input_strides,
+                                                 index_dims,
+                                                 index_strides,
+                                                 slice_offset,
+                                                 x_grad);
   }
 
   auto out_grad_dims = out_grad.dims();
@@ -323,15 +312,13 @@ void IndexElementwisePutGradKernel(
     DenseTensor* x_grad,
     DenseTensor* value_grad) {
   const auto& index_type = indices[0]->dtype();
-  PADDLE_ENFORCE_EQ(
-      index_type == phi::DataType::INT32 || index_type == phi::DataType::INT64,
-      true,
-      common::errors::InvalidArgument(
-          "Index holds the wrong type, it holds [%s], but "
-          "desires to be [%s] or [%s].",
-          index_type,
-          phi::DataType::INT32,
-          phi::DataType::INT64));
+  PADDLE_ENFORCE_EQ(index_type == phi::DataType::INT64,
+                    true,
+                    common::errors::InvalidArgument(
+                        "Index holds the wrong type, it holds [%s], but "
+                        "desires to be [%s].",
+                        index_type,
+                        phi::DataType::INT64));
 
   std::vector<DenseTensor> tmp_args;
   std::vector<const phi::DenseTensor*> int_indices_v =

paddle/phi/kernels/gpu/index_elementwise_put_kernel.cu

@@ -113,42 +113,26 @@ void IndexElementwisePutKernel(const Context& dev_ctx,
                                const int64_t slice_offset,
                                DenseTensor* out) {
   const auto& index_type = index[0]->dtype();
-  PADDLE_ENFORCE_EQ(
-      index_type == phi::DataType::INT32 || index_type == phi::DataType::INT64,
-      true,
-      common::errors::InvalidArgument(
-          "Index holds the wrong type, it holds [%s], but "
-          "desires to be [%s] or [%s].",
-          index_type,
-          phi::DataType::INT32,
-          phi::DataType::INT64));
+  PADDLE_ENFORCE_EQ(index_type == phi::DataType::INT64,
+                    true,
+                    common::errors::InvalidArgument(
+                        "Index holds the wrong type, it holds [%s], but "
+                        "desires to be [%s].",
+                        index_type,
+                        phi::DataType::INT64));
 
-  if (out->numel() == 0) return;
   dev_ctx.template Alloc<T>(out);
-
-  if (index_type == phi::DataType::INT32) {
-    GPUIndexElementwisePutKernel<T, int>(dev_ctx,
-                                         x,
-                                         value,
-                                         index,
-                                         input_dims,
-                                         input_strides,
-                                         index_dims,
-                                         index_strides,
-                                         slice_offset,
-                                         out);
-  } else if (index_type == phi::DataType::INT64) {
-    GPUIndexElementwisePutKernel<T, int64_t>(dev_ctx,
-                                             x,
-                                             value,
-                                             index,
-                                             input_dims,
-                                             input_strides,
-                                             index_dims,
-                                             index_strides,
-                                             slice_offset,
-                                             out);
-  }
+  if (out->numel() == 0) return;
+  GPUIndexElementwisePutKernel<T, int64_t>(dev_ctx,
+                                           x,
+                                           value,
+                                           index,
+                                           input_dims,
+                                           input_strides,
+                                           index_dims,
+                                           index_strides,
+                                           slice_offset,
+                                           out);
 }
 
 }  // namespace phi