!15720 modify static check

From: @lyvette
Reviewed-by: @jpc_chenjianping,@zhanghaibo5
Signed-off-by: @jpc_chenjianping

mindspore/lite/src/ops/compat/v0/broadcast_to_compat_v0.cc

@@ -31,7 +31,17 @@ int TransferBroadcastToAttr(Model::Node *node, std::vector<schema::Tensor *> *ds
   }
   dst_tensors->clear();
   auto prim = reinterpret_cast<const schema::v0::Primitive *>(node->primitive_);
-  auto dst_shape_attr = prim->value_as_BroadcastTo()->dst_shape();
+  MS_ASSERT(prim != nullptr);
+  auto param = prim->value_as_BroadcastTo();
+  if (param == nullptr) {
+    MS_LOG(ERROR) << "param is nullptr";
+    return RET_ERROR;
+  }
+  auto dst_shape_attr = param->dst_shape();
+  if (dst_shape_attr == nullptr) {
+    MS_LOG(ERROR) << "dst_shape_attr is nullptr";
+    return RET_ERROR;
+  }
   std::vector<int> dst_shape = std::vector<int>(dst_shape_attr->begin(), dst_shape_attr->end());
   auto dst_shape_tensor = AttrToTensor(dst_shape.data(), dst_shape.size(), true, kNumberTypeInt32, tensor_bufs);
   if (dst_shape_tensor == nullptr) {

mindspore/lite/src/ops/compat/v0/cast_compat_v0.cc

@@ -26,7 +26,13 @@ int TransferCastAttr(Model::Node *node, std::vector<schema::Tensor *> *dst_tenso
   }
   dst_tensors->clear();
   auto prim = reinterpret_cast<const schema::v0::Primitive *>(node->primitive_);
-  auto dst_type_attr = prim->value_as_Cast()->dstT();
+  MS_ASSERT(prim != nullptr);
+  auto param = prim->value_as_Cast();
+  if (param == nullptr) {
+    MS_LOG(ERROR) << "param is nullptr";
+    return RET_ERROR;
+  }
+  auto dst_type_attr = param->dstT();
   auto dst_type_tensor = AttrToTensor(&dst_type_attr, 1, false, kNumberTypeInt32, tensor_bufs);
   if (dst_type_tensor == nullptr) {
     MS_LOG(ERROR) << "attr tensor is nullptr, transform is failed.";

mindspore/lite/src/ops/compat/v0/expand_dims_compat_v0.cc

@@ -29,7 +29,13 @@ int TransferExpandDimsAttr(Model::Node *node, std::vector<schema::Tensor *> *dst
   MS_ASSERT(dst_tensors->size() == 0);
 
   auto prim = reinterpret_cast<const schema::v0::Primitive *>(node->primitive_);
-  int32_t dim = prim->value_as_ExpandDims()->dim();
+  MS_ASSERT(prim != nullptr);
+  auto param = prim->value_as_ExpandDims();
+  if (param == nullptr) {
+    MS_LOG(ERROR) << "param is nullptr";
+    return RET_ERROR;
+  }
+  int32_t dim = param->dim();
   auto dim_tensor = AttrToTensor(&dim, 1, false, kNumberTypeInt32, tensor_bufs);
   if (dim_tensor == nullptr) {
     MS_LOG(ERROR) << "transfer expand dim tensor failed.";

mindspore/lite/src/ops/compat/v0/fill_compat_v0.cc

@@ -31,7 +31,17 @@ int TransferFillToAttr(Model::Node *node, std::vector<schema::Tensor *> *dst_ten
   }
   dst_tensors->clear();
   auto prim = reinterpret_cast<const schema::v0::Primitive *>(node->primitive_);
-  auto dims_attr = prim->value_as_Fill()->dims();
+  MS_ASSERT(prim != nullptr);
+  auto param = prim->value_as_Fill();
+  if (param == nullptr) {
+    MS_LOG(ERROR) << "param is nullptr";
+    return RET_ERROR;
+  }
+  auto dims_attr = param->dims();
+  if (dims_attr == nullptr) {
+    MS_LOG(ERROR) << "dims_attr is nullptr";
+    return RET_ERROR;
+  }
   std::vector<int> dims = std::vector<int>(dims_attr->begin(), dims_attr->end());
   auto dims_tensor = AttrToTensor(dims.data(), dims.size(), true, kNumberTypeInt32, tensor_bufs);
   if (dims_tensor == nullptr) {

mindspore/lite/src/ops/compat/v0/gather_compat_v0.cc

@@ -27,7 +27,13 @@ int TransferGatherAttr(Model::Node *node, std::vector<schema::Tensor *> *dst_ten
   }
   dst_tensors->clear();
   auto prim = reinterpret_cast<const schema::v0::Primitive *>(node->primitive_);
-  auto axis_attr = prim->value_as_Gather()->axis();
+  MS_ASSERT(prim != nullptr);
+  auto param = prim->value_as_Gather();
+  if (param == nullptr) {
+    MS_LOG(ERROR) << "param is nullptr";
+    return RET_ERROR;
+  }
+  auto axis_attr = param->axis();
   auto axis_tensor = AttrToTensor(&axis_attr, 1, false, kNumberTypeInt32, tensor_bufs);
   if (axis_tensor == nullptr) {
     MS_LOG(ERROR) << "attr tensor is nullptr, transform is failed.";

mindspore/lite/src/ops/compat/v0/pad_compat_v0.cc

@@ -30,7 +30,17 @@ int TransferPadAttr(Model::Node *node, std::vector<schema::Tensor *> *dst_tensor
     return RET_OK;
   }
   auto prim = reinterpret_cast<const schema::v0::Primitive *>(node->primitive_);
-  auto paddings_attr = prim->value_as_Pad()->paddings();
+  MS_ASSERT(prim != nullptr);
+  auto param = prim->value_as_Pad();
+  if (param == nullptr) {
+    MS_LOG(ERROR) << "param is nullptr";
+    return RET_ERROR;
+  }
+  auto paddings_attr = param->paddings();
+  if (paddings_attr == nullptr) {
+    MS_LOG(ERROR) << "paddings_attr is nullptr";
+    return RET_ERROR;
+  }
   std::vector<int> paddings = std::vector<int>(paddings_attr->begin(), paddings_attr->end());
   auto paddings_tensor = AttrToTensor(paddings.data(), paddings.size(), true, kNumberTypeInt32, tensor_bufs);
   if (paddings_tensor == nullptr) {

mindspore/lite/src/ops/compat/v0/permute_compat_v0.cc

@@ -31,8 +31,17 @@ int TransferPermuteAttr(Model::Node *node, std::vector<schema::Tensor *> *dst_te
   }
   dst_tensors->clear();
   auto prim = reinterpret_cast<const schema::v0::Primitive *>(node->primitive_);
-  auto order_attr = prim->value_as_Permute()->order();
-
+  MS_ASSERT(prim != nullptr);
+  auto param = prim->value_as_Permute();
+  if (param == nullptr) {
+    MS_LOG(ERROR) << "param is nullptr";
+    return RET_ERROR;
+  }
+  auto order_attr = param->order();
+  if (order_attr == nullptr) {
+    MS_LOG(ERROR) << "order_attr is nullptr";
+    return RET_ERROR;
+  }
   std::vector<int> dst_shape;
   for (auto it = order_attr->begin(); it != order_attr->end(); ++it) {
     dst_shape.push_back(static_cast<int>(*it));

mindspore/lite/src/ops/compat/v0/power_compat_v0.cc

@@ -31,7 +31,13 @@ int TransferPowerToAttr(Model::Node *node, std::vector<schema::Tensor *> *dst_te
   }
   dst_tensors->clear();
   auto prim = reinterpret_cast<const schema::v0::Primitive *>(node->primitive_);
-  auto power_attr = prim->value_as_Power()->power();
+  MS_ASSERT(prim != nullptr);
+  auto param = prim->value_as_Power();
+  if (param == nullptr) {
+    MS_LOG(ERROR) << "param is nullptr";
+    return RET_ERROR;
+  }
+  auto power_attr = param->power();
   auto power_tensor = AttrToTensor(&power_attr, 1, false, kNumberTypeFloat32, tensor_bufs);
   if (power_tensor == nullptr) {
     MS_LOG(ERROR) << "attr tensor is nullptr, transform is failed.";

mindspore/lite/src/ops/compat/v0/reduce_compat_v0.cc

@@ -31,7 +31,17 @@ int TransferReduceToAttr(Model::Node *node, std::vector<schema::Tensor *> *dst_t
   }
   dst_tensors->clear();
   auto prim = reinterpret_cast<const schema::v0::Primitive *>(node->primitive_);
-  auto axes_attr = prim->value_as_Reduce()->axes();
+  MS_ASSERT(prim != nullptr);
+  auto param = prim->value_as_Reduce();
+  if (param == nullptr) {
+    MS_LOG(ERROR) << "param is nullptr";
+    return RET_ERROR;
+  }
+  auto axes_attr = param->axes();
+  if (axes_attr == nullptr) {
+    MS_LOG(ERROR) << "axes_attr is nullptr";
+    return RET_ERROR;
+  }
   std::vector<int> axes = std::vector<int>(axes_attr->begin(), axes_attr->end());
   auto axes_tensor = AttrToTensor(axes.data(), axes.size(), true, kNumberTypeInt32, tensor_bufs);
   if (axes_tensor == nullptr) {

mindspore/lite/src/ops/compat/v0/reshape_compat_v0.cc

@@ -31,7 +31,17 @@ int TransferReshapeAttr(Model::Node *node, std::vector<schema::Tensor *> *dst_te
   }
   dst_tensors->clear();
   auto prim = reinterpret_cast<const schema::v0::Primitive *>(node->primitive_);
-  auto dst_shape_attr = prim->value_as_Reshape()->shape();
+  MS_ASSERT(prim != nullptr);
+  auto param = prim->value_as_Reshape();
+  if (param == nullptr) {
+    MS_LOG(ERROR) << "param is nullptr";
+    return RET_ERROR;
+  }
+  auto dst_shape_attr = param->shape();
+  if (dst_shape_attr == nullptr) {
+    MS_LOG(ERROR) << "dst_shape_attr is nullptr";
+    return RET_ERROR;
+  }
   std::vector<int> dst_shape = std::vector<int>(dst_shape_attr->begin(), dst_shape_attr->end());
   auto dst_shape_tensor = AttrToTensor(dst_shape.data(), dst_shape.size(), true, kNumberTypeInt32, tensor_bufs);
   if (dst_shape_tensor == nullptr) {

mindspore/lite/src/ops/compat/v0/slice_compat_v0.cc

@@ -30,9 +30,19 @@ int TransferSliceAttr(Model::Node *node, std::vector<schema::Tensor *> *dst_tens
   }
   MS_ASSERT(dst_tensors->size() == 0);
   auto prim = reinterpret_cast<const schema::v0::Primitive *>(node->primitive_);
+  MS_ASSERT(prim != nullptr);
 
   /* transfer begin tensor */
-  auto begin_attr = prim->value_as_Slice()->begin();
+  auto param = prim->value_as_Slice();
+  if (param == nullptr) {
+    MS_LOG(ERROR) << "param is nullptr";
+    return RET_ERROR;
+  }
+  auto begin_attr = param->begin();
+  if (begin_attr == nullptr) {
+    MS_LOG(ERROR) << "begin_attr is nullptr";
+    return RET_ERROR;
+  }
   std::vector<int32_t> begin_shape = std::vector<int>(begin_attr->begin(), begin_attr->end());
   auto begin_tensor = AttrToTensor(begin_shape.data(), begin_shape.size(), true, kNumberTypeInt32, tensor_bufs);
   if (begin_tensor == nullptr) {
@@ -42,7 +52,11 @@ int TransferSliceAttr(Model::Node *node, std::vector<schema::Tensor *> *dst_tens
   dst_tensors->push_back(begin_tensor);
 
   /* transfer size tensor */
-  auto size_attr = prim->value_as_Slice()->size();
+  auto size_attr = param->size();
+  if (size_attr == nullptr) {
+    MS_LOG(ERROR) << "size_attr is nullptr";
+    return RET_ERROR;
+  }
   std::vector<int32_t> size_shape = std::vector<int>(size_attr->begin(), size_attr->end());
   auto size_tensor = AttrToTensor(size_shape.data(), size_shape.size(), true, kNumberTypeInt32, tensor_bufs);
   if (size_tensor == nullptr) {

mindspore/lite/src/ops/compat/v0/strided_slice_compat_v0.cc

@@ -27,22 +27,41 @@ int TransferStridedSliceAttr(Model::Node *node, std::vector<schema::Tensor *> *d
   }
   dst_tensors->clear();
   auto prim = reinterpret_cast<const schema::v0::Primitive *>(node->primitive_);
+  MS_ASSERT(prim != nullptr);
   int inputs_size = node->input_indices_.size();
+
+  auto param = prim->value_as_StridedSlice();
+  if (param == nullptr) {
+    MS_LOG(ERROR) << "param is nullptr";
+    return RET_ERROR;
+  }
   switch (inputs_size) {
     case 1: {
-      auto begins_attr = prim->value_as_StridedSlice()->begin();
+      auto begins_attr = param->begin();
+      if (begins_attr == nullptr) {
+        MS_LOG(ERROR) << "begins_attr is nullptr";
+        return RET_ERROR;
+      }
       std::vector<int> dst_begins = std::vector<int>(begins_attr->begin(), begins_attr->end());
       auto dst_begins_tensor = AttrToTensor(dst_begins.data(), dst_begins.size(), true, kNumberTypeInt32, tensor_bufs);
       dst_tensors->push_back(dst_begins_tensor);
     }
     case 2: {
-      auto ends_attr = prim->value_as_StridedSlice()->end();
+      auto ends_attr = param->end();
+      if (ends_attr == nullptr) {
+        MS_LOG(ERROR) << "ends_attr is nullptr";
+        return RET_ERROR;
+      }
       std::vector<int> dst_ends = std::vector<int>(ends_attr->begin(), ends_attr->end());
       auto dst_ends_tensor = AttrToTensor(dst_ends.data(), dst_ends.size(), true, kNumberTypeInt32, tensor_bufs);
       dst_tensors->push_back(dst_ends_tensor);
     }
     case 3: {
-      auto strides_attr = prim->value_as_StridedSlice()->stride();
+      auto strides_attr = param->stride();
+      if (strides_attr == nullptr) {
+        MS_LOG(ERROR) << "strides_attr is nullptr";
+        return RET_ERROR;
+      }
       std::vector<int> dst_strides = std::vector<int>(strides_attr->begin(), strides_attr->end());
       auto dst_strides_tensor =
         AttrToTensor(dst_strides.data(), dst_strides.size(), true, kNumberTypeInt32, tensor_bufs);

mindspore/lite/src/ops/compat/v0/tile_compat_v0.cc

@@ -31,7 +31,17 @@ int TransferTileToAttr(Model::Node *node, std::vector<schema::Tensor *> *dst_ten
   }
   dst_tensors->clear();
   auto prim = reinterpret_cast<const schema::v0::Primitive *>(node->primitive_);
-  auto multiples_attr = prim->value_as_Tile()->multiples();
+  MS_ASSERT(prim != nullptr);
+  auto param = prim->value_as_Tile();
+  if (param == nullptr) {
+    MS_LOG(ERROR) << "param is nullptr";
+    return RET_ERROR;
+  }
+  auto multiples_attr = param->multiples();
+  if (multiples_attr == nullptr) {
+    MS_LOG(ERROR) << "multiples_attr is nullptr";
+    return RET_ERROR;
+  }
   std::vector<int> multiples = std::vector<int>(multiples_attr->begin(), multiples_attr->end());
   auto multiples_tensor = AttrToTensor(multiples.data(), multiples.size(), true, kNumberTypeInt32, tensor_bufs);
   if (multiples_tensor == nullptr) {

mindspore/lite/src/ops/compat/v0/topk_compat_v0.cc

@@ -30,7 +30,13 @@ int TransferTopkAttr(Model::Node *node, std::vector<schema::Tensor *> *dst_tenso
   }
   MS_ASSERT(dst_tensors->size() == 0);
   auto prim = reinterpret_cast<const schema::v0::Primitive *>(node->primitive_);
-  int32_t topk_k = prim->value_as_TopK()->k();
+  MS_ASSERT(prim != nullptr);
+  auto param = prim->value_as_TopK();
+  if (param == nullptr) {
+    MS_LOG(ERROR) << "param is nullptr";
+    return RET_ERROR;
+  }
+  int32_t topk_k = param->k();
   auto k_tensor = AttrToTensor(&topk_k, 1, false, kNumberTypeInt32, tensor_bufs);
   if (k_tensor == nullptr) {
     MS_LOG(ERROR) << "attr tensor is nullptr, transform is failed.";

mindspore/lite/src/ops/compat/v0/transpose_compat_v0.cc

@@ -31,7 +31,17 @@ int TransferTransposeAttr(Model::Node *node, std::vector<schema::Tensor *> *dst_
   }
   dst_tensors->clear();
   auto prim = reinterpret_cast<const schema::v0::Primitive *>(node->primitive_);
-  auto perm_attr = prim->value_as_Transpose()->perm();
+  MS_ASSERT(prim != nullptr);
+  auto param = prim->value_as_Transpose();
+  if (param == nullptr) {
+    MS_LOG(ERROR) << "param is nullptr";
+    return RET_ERROR;
+  }
+  auto perm_attr = param->perm();
+  if (perm_attr == nullptr) {
+    MS_LOG(ERROR) << "perm_attr is nullptr";
+    return RET_ERROR;
+  }
   std::vector<int> dst_shape = std::vector<int>(perm_attr->begin(), perm_attr->end());
   auto dst_shape_tensor = AttrToTensor(dst_shape.data(), dst_shape.size(), true, kNumberTypeInt32, tensor_bufs);
   if (dst_shape_tensor == nullptr) {

mindspore/lite/src/ops/populate/activation_grad_populate.cc

@@ -20,8 +20,7 @@ using mindspore::schema::PrimitiveType_ActivationGrad;
 namespace mindspore {
 namespace lite {
 OpParameter *PopulateActivationGradParameter(const void *prim) {
-  ActivationGradParameter *act_param =
-    reinterpret_cast<ActivationGradParameter *>(malloc(sizeof(ActivationGradParameter)));
+  auto *act_param = reinterpret_cast<ActivationGradParameter *>(malloc(sizeof(ActivationGradParameter)));
   if (act_param == nullptr) {
     MS_LOG(ERROR) << "malloc ActivationParameter failed.";
     return nullptr;
@@ -29,7 +28,12 @@ OpParameter *PopulateActivationGradParameter(const void *prim) {
   memset(act_param, 0, sizeof(ActivationGradParameter));
 
   auto primitive = static_cast<const schema::Primitive *>(prim);
+  MS_ASSERT(primitive != nullptr);
   auto value = primitive->value_as_ActivationGrad();
+  if (value == nullptr) {
+    MS_LOG(ERROR) << "value is nullptr";
+    return nullptr;
+  }
   act_param->op_parameter.type_ = primitive->value_type();
   act_param->type_ = static_cast<int>(value->activation_type());
   act_param->alpha_ = value->alpha();

mindspore/lite/src/ops/populate/activation_populate.cc

@@ -21,15 +21,20 @@ namespace mindspore {
 namespace lite {
 namespace {
 OpParameter *PopulateRelu6Parameter(const void *prim) {
-  ActivationParameter *act_param = reinterpret_cast<ActivationParameter *>(malloc(sizeof(ActivationParameter)));
+  auto *act_param = reinterpret_cast<ActivationParameter *>(malloc(sizeof(ActivationParameter)));
   if (act_param == nullptr) {
     MS_LOG(ERROR) << "malloc ActivationParameter failed.";
     return nullptr;
   }
   memset(act_param, 0, sizeof(ActivationParameter));
   auto primitive = static_cast<const schema::Primitive *>(prim);
+  MS_ASSERT(primitive != nullptr);
   act_param->op_parameter_.type_ = primitive->value_type();
   auto acti_prim = primitive->value_as_Activation();
+  if (acti_prim == nullptr) {
+    MS_LOG(ERROR) << "acti_prim is nullptr";
+    return nullptr;
+  }
   act_param->type_ = static_cast<int>(acti_prim->activation_type());
   act_param->alpha_ = acti_prim->alpha();
   act_param->min_val_ = acti_prim->min_val();

mindspore/lite/src/ops/populate/adam_populate.cc

@@ -19,13 +19,14 @@ using mindspore::schema::PrimitiveType_Adam;
 namespace mindspore {
 namespace lite {
 OpParameter *PopulateAdamParameter(const void *prim) {
-  OpParameter *param = reinterpret_cast<OpParameter *>(malloc(sizeof(OpParameter)));
+  auto *param = reinterpret_cast<OpParameter *>(malloc(sizeof(OpParameter)));
   if (param == nullptr) {
     MS_LOG(ERROR) << "malloc Adam Parameter failed.";
     return nullptr;
   }
   memset(param, 0, sizeof(OpParameter));
   auto primitive = static_cast<const schema::Primitive *>(prim);
+  MS_ASSERT(primitive != nullptr);
   param->type_ = primitive->value_type();
   return param;
 }

mindspore/lite/src/ops/populate/add_populate.cc

@@ -30,6 +30,10 @@ OpParameter *PopulateAddParameter(const void *prim) {
   auto *primitive = static_cast<const schema::Primitive *>(prim);
   param->op_parameter_.type_ = primitive->value_type();
   auto add_prim = primitive->value_as_AddFusion();
+  if (add_prim == nullptr) {
+    MS_LOG(ERROR) << "add_prim is nullptr";
+    return nullptr;
+  }
   param->activation_type_ = add_prim->activation_type();
   return reinterpret_cast<OpParameter *>(param);
 }

mindspore/lite/src/ops/populate/adder_populate.cc

@@ -29,19 +29,32 @@ OpParameter *PopulateAdderParameter(const void *prim) {
   memset(conv_param, 0, sizeof(ConvParameter));
 
   auto primitive = static_cast<const schema::Primitive *>(prim);
+  MS_ASSERT(primitive != nullptr);
   conv_param->op_parameter_.type_ = primitive->value_type();
   auto conv_primitive = primitive->value_as_AdderFusion();
-  conv_param->kernel_h_ = static_cast<int>(*(conv_primitive->kernel_size()->begin()));
-  conv_param->kernel_w_ = static_cast<int>(*(conv_primitive->kernel_size()->begin() + 1));
+  if (conv_primitive == nullptr) {
+    MS_LOG(ERROR) << "conv_primitive is nullptr";
+    return nullptr;
+  }
+  auto kernel_size = conv_primitive->kernel_size();
+  auto stride = conv_primitive->stride();
+  auto pad_list = conv_primitive->pad_list();
+  auto dilation = conv_primitive->dilation();
+  if (kernel_size == nullptr || stride == nullptr || pad_list == nullptr || dilation == nullptr) {
+    MS_LOG(ERROR) << "nullptr";
+    return nullptr;
+  }
+  conv_param->kernel_h_ = static_cast<int>(*(kernel_size->begin()));
+  conv_param->kernel_w_ = static_cast<int>(*(kernel_size->begin() + 1));
   conv_param->group_ = static_cast<int>(conv_primitive->group());
-  conv_param->stride_h_ = static_cast<int>(*(conv_primitive->stride()->begin()));
-  conv_param->stride_w_ = static_cast<int>(*(conv_primitive->stride()->begin() + 1));
-  conv_param->pad_u_ = static_cast<int>(*(conv_primitive->pad_list()->begin()));
-  conv_param->pad_d_ = static_cast<int>(*(conv_primitive->pad_list()->begin() + 1));
-  conv_param->pad_l_ = static_cast<int>(*(conv_primitive->pad_list()->begin() + 2));
-  conv_param->pad_r_ = static_cast<int>(*(conv_primitive->pad_list()->begin() + 3));
-  conv_param->dilation_h_ = static_cast<int>(*(conv_primitive->dilation()->begin()));
-  conv_param->dilation_w_ = static_cast<int>(*(conv_primitive->dilation()->begin() + 1));
+  conv_param->stride_h_ = static_cast<int>(*(stride->begin()));
+  conv_param->stride_w_ = static_cast<int>(*(stride->begin() + 1));
+  conv_param->pad_u_ = static_cast<int>(*(pad_list->begin()));
+  conv_param->pad_d_ = static_cast<int>(*(pad_list->begin() + 1));
+  conv_param->pad_l_ = static_cast<int>(*(pad_list->begin() + 2));
+  conv_param->pad_r_ = static_cast<int>(*(pad_list->begin() + 3));
+  conv_param->dilation_h_ = static_cast<int>(*(dilation->begin()));
+  conv_param->dilation_w_ = static_cast<int>(*(dilation->begin() + 1));
   conv_param->input_channel_ = static_cast<int>(conv_primitive->in_channel());
   conv_param->output_channel_ = static_cast<int>(conv_primitive->out_channel());
   auto act_type = conv_primitive->activation_type();

mindspore/lite/src/ops/populate/addn_populate.cc

@@ -21,13 +21,14 @@ namespace mindspore {
 namespace lite {
 namespace {
 OpParameter *PopulateAddNParameter(const void *prim) {
-  OpParameter *addn_param = reinterpret_cast<OpParameter *>(malloc(sizeof(OpParameter)));
+  auto *addn_param = reinterpret_cast<OpParameter *>(malloc(sizeof(OpParameter)));
   if (addn_param == nullptr) {
     MS_LOG(ERROR) << "malloc OpParameter failed.";
     return nullptr;
   }
   memset(addn_param, 0, sizeof(OpParameter));
   auto primitive = static_cast<const schema::Primitive *>(prim);
+  MS_ASSERT(primitive != nullptr);
   addn_param->type_ = primitive->value_type();
   return reinterpret_cast<OpParameter *>(addn_param);
 }

mindspore/lite/src/ops/populate/argmax_populate.cc

@@ -21,7 +21,7 @@ namespace mindspore {
 namespace lite {
 namespace {
 OpParameter *PopulateArgMaxParameter(const void *prim) {
-  ArgMinMaxParameter *arg_param = reinterpret_cast<ArgMinMaxParameter *>(malloc(sizeof(ArgMinMaxParameter)));
+  auto *arg_param = reinterpret_cast<ArgMinMaxParameter *>(malloc(sizeof(ArgMinMaxParameter)));
   if (arg_param == nullptr) {
     MS_LOG(ERROR) << "malloc ArgMinMaxParameter failed.";
     return nullptr;
@@ -30,6 +30,10 @@ OpParameter *PopulateArgMaxParameter(const void *prim) {
   auto *primitive = static_cast<const schema::Primitive *>(prim);
   arg_param->op_parameter_.type_ = primitive->value_type();
   auto param = primitive->value_as_ArgMaxFusion();
+  if (param == nullptr) {
+    MS_LOG(ERROR) << "param is nullptr";
+    return nullptr;
+  }
   arg_param->axis_ = param->axis();
   arg_param->topk_ = param->top_k();
   arg_param->out_value_ = param->out_max_value();

mindspore/lite/src/ops/populate/argmin_populate.cc

@@ -30,6 +30,10 @@ OpParameter *PopulateArgMinParameter(const void *prim) {
   auto *primitive = static_cast<const schema::Primitive *>(prim);
   arg_param->op_parameter_.type_ = primitive->value_type();
   auto param = primitive->value_as_ArgMinFusion();
+  if (param == nullptr) {
+    MS_LOG(ERROR) << "param is nullptr";
+    return nullptr;
+  }
   arg_param->axis_ = param->axis();
   arg_param->topk_ = param->top_k();
   arg_param->out_value_ = param->out_max_value();

mindspore/lite/src/ops/populate/arithmetic_populate.cc

@@ -36,13 +36,14 @@ using mindspore::schema::PrimitiveType_SquaredDifference;
 namespace mindspore {
 namespace lite {
 ArithmeticParameter *PopulateArithmeticCommonPara(const void *prim) {
-  ArithmeticParameter *param = reinterpret_cast<ArithmeticParameter *>(malloc(sizeof(ArithmeticParameter)));
+  auto *param = reinterpret_cast<ArithmeticParameter *>(malloc(sizeof(ArithmeticParameter)));
   if (param == nullptr) {
     MS_LOG(ERROR) << "malloc ArithmeticParameter failed.";
     return nullptr;
   }
   memset(param, 0, sizeof(ArithmeticParameter));
-  const schema::Primitive *primitive = static_cast<const schema::Primitive *>(prim);
+  auto *primitive = static_cast<const schema::Primitive *>(prim);
+  MS_ASSERT(primitive != nullptr);
   param->op_parameter_.type_ = primitive->value_type();
   param->broadcasting_ = false;
   param->ndim_ = 0;

mindspore/lite/src/ops/populate/arithmetic_self_populate.cc

@@ -35,14 +35,14 @@ using mindspore::schema::PrimitiveType_Square;
 namespace mindspore {
 namespace lite {
 OpParameter *PopulateArithmeticSelf(const void *prim) {
-  ArithmeticSelfParameter *arithmetic_self_param =
-    reinterpret_cast<ArithmeticSelfParameter *>(malloc(sizeof(ArithmeticSelfParameter)));
+  auto *arithmetic_self_param = reinterpret_cast<ArithmeticSelfParameter *>(malloc(sizeof(ArithmeticSelfParameter)));
   if (arithmetic_self_param == nullptr) {
     MS_LOG(ERROR) << "malloc ArithmeticSelfParameter failed.";
     return nullptr;
   }
   memset(arithmetic_self_param, 0, sizeof(ArithmeticSelfParameter));
-  const schema::Primitive *primitive = static_cast<const schema::Primitive *>(prim);
+  auto *primitive = static_cast<const schema::Primitive *>(prim);
+  MS_ASSERT(primitive != nullptr);
   arithmetic_self_param->op_parameter_.type_ = primitive->value_type();
   return reinterpret_cast<OpParameter *>(arithmetic_self_param);
 }

mindspore/lite/src/ops/populate/assert_populate.cc

@@ -20,13 +20,14 @@ namespace mindspore {
 namespace lite {
 
 OpParameter *PopulateAssertParameter(const void *prim) {
-  OpParameter *assert_parameter = reinterpret_cast<OpParameter *>(malloc(sizeof(OpParameter)));
+  auto *assert_parameter = reinterpret_cast<OpParameter *>(malloc(sizeof(OpParameter)));
   if (assert_parameter == nullptr) {
     MS_LOG(ERROR) << "malloc AssertParameter failed.";
     return nullptr;
   }
   memset(assert_parameter, 0, sizeof(OpParameter));
   auto primitive = static_cast<const schema::Primitive *>(prim);
+  MS_ASSERT(primitive != nullptr);
   assert_parameter->type_ = primitive->value_type();
 
   return reinterpret_cast<OpParameter *>(assert_parameter);

mindspore/lite/src/ops/populate/assign_add_populate.cc

@@ -19,13 +19,14 @@ using mindspore::schema::PrimitiveType_AssignAdd;
 namespace mindspore {
 namespace lite {
 OpParameter *PopulateAssignAddParameter(const void *prim) {
-  OpParameter *param = reinterpret_cast<OpParameter *>(malloc(sizeof(OpParameter)));
+  auto *param = reinterpret_cast<OpParameter *>(malloc(sizeof(OpParameter)));
   if (param == nullptr) {
     MS_LOG(ERROR) << "malloc AssignAdd Parameter failed.";
     return nullptr;
   }
   memset(param, 0, sizeof(OpParameter));
   auto primitive = static_cast<const schema::Primitive *>(prim);
+  MS_ASSERT(primitive != nullptr);
   param->type_ = primitive->value_type();
   return param;
 }

mindspore/lite/src/ops/populate/assign_populate.cc

@@ -19,7 +19,7 @@ using mindspore::schema::PrimitiveType_Assign;
 namespace mindspore {
 namespace lite {
 OpParameter *PopulateAssignParameter(const void *prim) {
-  OpParameter *param = reinterpret_cast<OpParameter *>(malloc(sizeof(OpParameter)));
+  auto *param = reinterpret_cast<OpParameter *>(malloc(sizeof(OpParameter)));
   if (param == nullptr) {
     MS_LOG(ERROR) << "malloc Assign Parameter failed.";
     return nullptr;
@@ -27,6 +27,7 @@ OpParameter *PopulateAssignParameter(const void *prim) {
   memset(param, 0, sizeof(OpParameter));
 
   auto primitive = static_cast<const schema::Primitive *>(prim);
+  MS_ASSERT(primitive != nullptr);
   param->type_ = primitive->value_type();
   return param;
 }

mindspore/lite/src/ops/populate/audio_spectrogram_populate.cc

@@ -21,8 +21,7 @@ namespace mindspore {
 namespace lite {
 namespace {
 OpParameter *PopulateAudioSpectrogramParameter(const void *prim) {
-  AudioSpectrogramParameter *arg_param =
-    reinterpret_cast<AudioSpectrogramParameter *>(malloc(sizeof(AudioSpectrogramParameter)));
+  auto *arg_param = reinterpret_cast<AudioSpectrogramParameter *>(malloc(sizeof(AudioSpectrogramParameter)));
   if (arg_param == nullptr) {
     MS_LOG(ERROR) << "malloc AudioSpectrogramParameter failed.";
     return nullptr;
@@ -31,6 +30,10 @@ OpParameter *PopulateAudioSpectrogramParameter(const void *prim) {
   auto *primitive = static_cast<const schema::Primitive *>(prim);
   arg_param->op_parameter_.type_ = primitive->value_type();
   auto param = primitive->value_as_AudioSpectrogram();
+  if (param == nullptr) {
+    MS_LOG(ERROR) << "param is nullptr";
+    return nullptr;
+  }
   arg_param->window_size_ = param->window_size();
   arg_param->stride_ = param->stride();
   return reinterpret_cast<OpParameter *>(arg_param);

mindspore/lite/src/ops/populate/batch_norm_populate.cc

@@ -21,15 +21,20 @@ namespace mindspore {
 namespace lite {
 namespace {
 OpParameter *PopulateBatchNorm(const void *prim) {
-  BatchNormParameter *batch_norm_param = reinterpret_cast<BatchNormParameter *>(malloc(sizeof(BatchNormParameter)));
+  auto *batch_norm_param = reinterpret_cast<BatchNormParameter *>(malloc(sizeof(BatchNormParameter)));
   if (batch_norm_param == nullptr) {
     MS_LOG(ERROR) << "malloc BatchNormParameter failed.";
     return nullptr;
   }
   memset(batch_norm_param, 0, sizeof(BatchNormParameter));
-  const schema::Primitive *primitive = static_cast<const schema::Primitive *>(prim);
+  auto *primitive = static_cast<const schema::Primitive *>(prim);
+  MS_ASSERT(primitive != nullptr);
   batch_norm_param->op_parameter_.type_ = primitive->value_type();
   auto prim_batchnorm = primitive->value_as_BatchNorm();
+  if (prim_batchnorm == nullptr) {
+    MS_LOG(ERROR) << "prim_batchnorm is nullptr";
+    return nullptr;
+  }
   batch_norm_param->epsilon_ = prim_batchnorm->epsilon();
   batch_norm_param->fused_ = false;
   return reinterpret_cast<OpParameter *>(batch_norm_param);

mindspore/lite/src/ops/populate/batch_to_space_populate.cc

@@ -22,30 +22,48 @@ namespace mindspore {
 namespace lite {
 namespace {
 OpParameter *PopulateBatchToSpaceParameter(const void *prim) {
-  BatchToSpaceParameter *batch_space_param =
-    reinterpret_cast<BatchToSpaceParameter *>(malloc(sizeof(BatchToSpaceParameter)));
+  auto *batch_space_param = reinterpret_cast<BatchToSpaceParameter *>(malloc(sizeof(BatchToSpaceParameter)));
   if (batch_space_param == nullptr) {
     MS_LOG(ERROR) << "malloc BatchToSpaceParameter failed.";
     return nullptr;
   }
   memset(batch_space_param, 0, sizeof(BatchToSpaceParameter));
-  const schema::Primitive *primitive = static_cast<const schema::Primitive *>(prim);
+  auto *primitive = static_cast<const schema::Primitive *>(prim);
+  MS_ASSERT(primitive != nullptr);
   batch_space_param->op_parameter_.type_ = primitive->value_type();
   auto param = primitive->value_as_BatchToSpace();
-  if (param->block_size() == nullptr) {
+  if (param == nullptr) {
+    MS_LOG(ERROR) << "param is nullptr";
+    return nullptr;
+  }
+  auto block_size = param->block_size();
+  if (block_size == nullptr) {
     return reinterpret_cast<OpParameter *>(batch_space_param);
   }
-  auto block_shape = std::vector<int64_t>(param->block_size()->begin(), param->block_size()->end());
+  auto block_shape = std::vector<int64_t>(block_size->begin(), block_size->end());
   if (block_shape.size() != BATCH_TO_SPACE_BLOCK_SHAPE_SIZE) {
     MS_LOG(ERROR) << "batch_to_space blockShape size should be " << BATCH_TO_SPACE_BLOCK_SHAPE_SIZE;
     free(batch_space_param);
     return nullptr;
   }
 
-  auto fb_crops = param->crops()->data();
+  auto crop = param->crops();
+  if (crop == nullptr) {
+    MS_LOG(ERROR) << "crop is nullptr";
+    return nullptr;
+  }
+  auto fb_crops = crop->data();
+  if (fb_crops == nullptr) {
+    MS_LOG(ERROR) << "fb_crops is nullptr";
+    return nullptr;
+  }
   std::vector<int64_t> crops;
   for (auto iter = fb_crops->begin(); iter != fb_crops->end(); ++iter) {
     auto crops_data = (*iter)->data();
+    if (crops_data == nullptr) {
+      MS_LOG(ERROR) << "crops_data is nullptr";
+      return nullptr;
+    }
     auto crops_vec = std::vector<int64_t>(crops_data->begin(), crops_data->end());
     crops.insert(crops.end(), crops_vec.begin(), crops_vec.end());
   }

mindspore/lite/src/ops/populate/bias_add_populate.cc

@@ -21,13 +21,14 @@ namespace mindspore {
 namespace lite {
 namespace {
 OpParameter *PopulateBiasAddParameter(const void *prim) {
-  ArithmeticParameter *arithmetic_param = reinterpret_cast<ArithmeticParameter *>(malloc(sizeof(ArithmeticParameter)));
+  auto *arithmetic_param = reinterpret_cast<ArithmeticParameter *>(malloc(sizeof(ArithmeticParameter)));
   if (arithmetic_param == nullptr) {
     MS_LOG(ERROR) << "malloc ArithmeticParameter failed.";
     return nullptr;
   }
   memset(arithmetic_param, 0, sizeof(ArithmeticParameter));
-  const schema::Primitive *primitive = static_cast<const schema::Primitive *>(prim);
+  auto *primitive = static_cast<const schema::Primitive *>(prim);
+  MS_ASSERT(primitive != nullptr);
   arithmetic_param->op_parameter_.type_ = primitive->value_type();
 
   return reinterpret_cast<OpParameter *>(arithmetic_param);

mindspore/lite/src/ops/populate/bias_grad_populate.cc

@@ -21,7 +21,7 @@ namespace mindspore {
 namespace lite {
 namespace {
 OpParameter *PopulateBiasAddGradParameter(const void *prim) {
-  ArithmeticParameter *arithmetic_param = reinterpret_cast<ArithmeticParameter *>(malloc(sizeof(ArithmeticParameter)));
+  auto *arithmetic_param = reinterpret_cast<ArithmeticParameter *>(malloc(sizeof(ArithmeticParameter)));
   if (arithmetic_param == nullptr) {
     MS_LOG(ERROR) << "malloc ArithmeticParameter failed.";
     return nullptr;
@@ -29,6 +29,7 @@ OpParameter *PopulateBiasAddGradParameter(const void *prim) {
   memset(arithmetic_param, 0, sizeof(ArithmeticParameter));
 
   auto primitive = static_cast<const schema::Primitive *>(prim);
+  MS_ASSERT(primitive != nullptr);
   arithmetic_param->op_parameter_.type_ = primitive->value_type();
   return reinterpret_cast<OpParameter *>(arithmetic_param);
 }

mindspore/lite/src/ops/populate/binary_cross_entropy_grad_populate.cc

@@ -21,7 +21,7 @@ namespace mindspore {
 namespace lite {
 namespace {
 OpParameter *PopulateBinaryCrossEntropyGradParameter(const void *prim) {
-  BinaryCrossEntropyGradParameter *bce_param =
+  auto *bce_param =
     reinterpret_cast<BinaryCrossEntropyGradParameter *>(malloc(sizeof(BinaryCrossEntropyGradParameter)));
   if (bce_param == nullptr) {
     MS_LOG(ERROR) << "malloc BinaryCrossEntropyGrad Parameter failed.";
@@ -29,8 +29,13 @@ OpParameter *PopulateBinaryCrossEntropyGradParameter(const void *prim) {
   }
   memset(bce_param, 0, sizeof(BinaryCrossEntropyGradParameter));
   auto *primitive = static_cast<const schema::Primitive *>(prim);
+  MS_ASSERT(primitive != nullptr);
   bce_param->op_parameter_.type_ = primitive->value_type();
   auto param = primitive->value_as_BinaryCrossEntropyGrad();
+  if (param == nullptr) {
+    MS_LOG(ERROR) << "param is nullptr";
+    return nullptr;
+  }
   bce_param->reduction = param->reduction();
   return reinterpret_cast<OpParameter *>(bce_param);
 }

mindspore/lite/src/ops/populate/binary_cross_entropy_populate.cc

@@ -28,7 +28,12 @@ OpParameter *PopulateBinaryCrossEntropyParameter(const void *prim) {
   }
   memset(bce_param, 0, sizeof(BinaryCrossEntropyParameter));
   auto primitive = static_cast<const schema::Primitive *>(prim);
+  MS_ASSERT(primitive != nullptr);
   auto value = primitive->value_as_BinaryCrossEntropy();
+  if (value == nullptr) {
+    MS_LOG(ERROR) << "value is nullptr";
+    return nullptr;
+  }
   bce_param->op_parameter_.type_ = primitive->value_type();
   bce_param->reduction = value->reduction();
   return reinterpret_cast<OpParameter *>(bce_param);

mindspore/lite/src/ops/populate/broadcast_to_populate.cc

@@ -20,17 +20,25 @@ using mindspore::schema::PrimitiveType_BroadcastTo;
 namespace mindspore {
 namespace lite {
 OpParameter *PopulateBroadcastToParameter(const void *prim) {
-  BroadcastToParameter *broadcast_param =
-    reinterpret_cast<BroadcastToParameter *>(malloc(sizeof(BroadcastToParameter)));
+  auto *broadcast_param = reinterpret_cast<BroadcastToParameter *>(malloc(sizeof(BroadcastToParameter)));
   if (broadcast_param == nullptr) {
     MS_LOG(ERROR) << "malloc BroadcastToParameter failed.";
     return nullptr;
   }
   memset(broadcast_param, 0, sizeof(BroadcastToParameter));
   auto primitive = static_cast<const schema::Primitive *>(prim);
+  MS_ASSERT(primitive != nullptr);
   auto value = primitive->value_as_BroadcastTo();
+  if (value == nullptr) {
+    MS_LOG(ERROR) << "value is nullptr";
+    return nullptr;
+  }
   broadcast_param->op_parameter_.type_ = primitive->value_type();
   auto dst_shape = value->shape();
+  if (dst_shape == nullptr) {
+    MS_LOG(ERROR) << "dst_shape is nullptr";
+    return nullptr;
+  }
   broadcast_param->shape_size_ = dst_shape->size();
   for (size_t i = 0; i < broadcast_param->shape_size_; ++i) {
     broadcast_param->shape_[i] = dst_shape->Get(i);

mindspore/lite/src/ops/populate/cast_populate.cc

@@ -20,13 +20,14 @@ namespace mindspore {
 namespace lite {
 namespace {
 OpParameter *PopulateCastParameter(const void *prim) {
-  OpParameter *cast_param = reinterpret_cast<OpParameter *>(malloc(sizeof(OpParameter)));
+  auto *cast_param = reinterpret_cast<OpParameter *>(malloc(sizeof(OpParameter)));
   if (cast_param == nullptr) {
     MS_LOG(ERROR) << "malloc CastParameter failed.";
     return nullptr;
   }
   memset(cast_param, 0, sizeof(OpParameter));
   auto *primitive = static_cast<const schema::Primitive *>(prim);
+  MS_ASSERT(primitive != nullptr);
   cast_param->type_ = primitive->value_type();
   return reinterpret_cast<OpParameter *>(cast_param);
 }

mindspore/lite/src/ops/populate/clip_populate.cc

@@ -20,13 +20,14 @@ namespace mindspore {
 namespace lite {
 namespace {
 OpParameter *PopulateClipParameter(const void *prim) {
-  OpParameter *act_param = reinterpret_cast<OpParameter *>(malloc(sizeof(OpParameter)));
+  auto *act_param = reinterpret_cast<OpParameter *>(malloc(sizeof(OpParameter)));
   if (act_param == nullptr) {
     MS_LOG(ERROR) << "malloc ClipParameter failed.";
     return nullptr;
   }
   memset(act_param, 0, sizeof(OpParameter));
   auto primitive = static_cast<const schema::Primitive *>(prim);
+  MS_ASSERT(primitive != nullptr);
   act_param->type_ = primitive->value_type();
   return reinterpret_cast<OpParameter *>(act_param);
 }

mindspore/lite/src/ops/populate/common_populate.cc

@@ -28,6 +28,7 @@ OpParameter *PopulateCommonParameter(const void *prim) {
   }
   memset(common_parameter, 0, sizeof(OpParameter));
   auto primitive = static_cast<const schema::Primitive *>(prim);
+  MS_ASSERT(primitive != nullptr);
   common_parameter->type_ = primitive->value_type();
   return common_parameter;
 }

mindspore/lite/src/ops/populate/concat_populate.cc

@@ -21,15 +21,21 @@ namespace mindspore {
 namespace lite {
 namespace {
 OpParameter *PopulateConcatParameter(const void *prim) {
-  ConcatParameter *concat_param = reinterpret_cast<ConcatParameter *>(malloc(sizeof(ConcatParameter)));
+  auto *concat_param = reinterpret_cast<ConcatParameter *>(malloc(sizeof(ConcatParameter)));
   if (concat_param == nullptr) {
     MS_LOG(ERROR) << "malloc ConcatParameter failed.";
     return nullptr;
   }
   memset(concat_param, 0, sizeof(ConcatParameter));
-  const schema::Primitive *primitive = static_cast<const schema::Primitive *>(prim);
+  auto *primitive = static_cast<const schema::Primitive *>(prim);
+  MS_ASSERT(primitive != nullptr);
   concat_param->op_parameter_.type_ = primitive->value_type();
-  concat_param->axis_ = static_cast<int>(primitive->value_as_Concat()->axis());
+  auto param = primitive->value_as_Concat();
+  if (param == nullptr) {
+    MS_LOG(ERROR) << "param is nullptr";
+    return nullptr;
+  }
+  concat_param->axis_ = static_cast<int>(param->axis());
   return reinterpret_cast<OpParameter *>(concat_param);
 }
 }  // namespace

mindspore/lite/src/ops/populate/constant_of_shape_populate.cc

@@ -20,27 +20,36 @@ using mindspore::schema::PrimitiveType_ConstantOfShape;
 namespace mindspore::lite {
 namespace {
 OpParameter *PopulateConstantOfShapeParameter(const void *prim) {
-  ConstantOfShapeParameter *param =
-    reinterpret_cast<ConstantOfShapeParameter *>(malloc(sizeof(ConstantOfShapeParameter)));
+  auto *param = reinterpret_cast<ConstantOfShapeParameter *>(malloc(sizeof(ConstantOfShapeParameter)));
   if (param == nullptr) {
     MS_LOG(ERROR) << "malloc ConstantOfShapeParameter failed.";
     return nullptr;
   }
   memset(param, 0, sizeof(ConstantOfShapeParameter));
   auto primitive = static_cast<const schema::Primitive *>(prim);
+  MS_ASSERT(primitive != nullptr);
   param->op_parameter_.type_ = primitive->value_type();
   auto attr = primitive->value_as_ConstantOfShape();
-  auto value = std::vector<float>(attr->value()->begin(), attr->value()->end());
+  if (attr == nullptr) {
+    MS_LOG(ERROR) << "attr is nullptr";
+    return nullptr;
+  }
+  auto val = attr->value();
+  if (val == nullptr) {
+    MS_LOG(ERROR) << "val is nullptr";
+    return nullptr;
+  }
+  auto value = std::vector<float>(val->begin(), val->end());
   param->data_type_ = static_cast<int>(attr->data_type());
   if (value.empty() || value.size() > 1) {
     MS_LOG(ERROR) << "The value of constant of shape is empty or more than 1.";
   } else {
     switch (param->data_type_) {
       case kNumberTypeFloat32:
-        param->value_.f32_value_ = *(attr->value()->begin());
+        param->value_.f32_value_ = *(val->begin());
         break;
       case kNumberTypeInt32:
-        param->value_.int32_value_ = *(attr->value()->begin());
+        param->value_.int32_value_ = *(val->begin());
         break;
       default:
         MS_LOG(ERROR) << "The value of constant of shape is invalid";

mindspore/lite/src/ops/populate/conv2d_populate.cc

@@ -22,20 +22,33 @@ namespace mindspore {
 namespace lite {
 namespace {
 OpParameter *PopulateConvParameter(const void *prim) {
-  ConvParameter *conv_param = reinterpret_cast<ConvParameter *>(malloc(sizeof(ConvParameter)));
+  auto *conv_param = reinterpret_cast<ConvParameter *>(malloc(sizeof(ConvParameter)));
   if (conv_param == nullptr) {
     MS_LOG(ERROR) << "malloc ConvParameter failed.";
     return nullptr;
   }
   memset(conv_param, 0, sizeof(ConvParameter));
   auto primitive = static_cast<const schema::Primitive *>(prim);
+  MS_ASSERT(primitive != nullptr);
   conv_param->op_parameter_.type_ = primitive->value_type();
   auto conv_primitive = primitive->value_as_Conv2DFusion();
-  conv_param->kernel_h_ = static_cast<int>(*(conv_primitive->kernel_size()->begin()));
-  conv_param->kernel_w_ = static_cast<int>(*(conv_primitive->kernel_size()->begin() + 1));
+  if (conv_primitive == nullptr) {
+    MS_LOG(ERROR) << "conv_primitive is nullptr";
+    return nullptr;
+  }
+  auto kernel_size = conv_primitive->kernel_size();
+  auto stride = conv_primitive->stride();
+  auto pad_list = conv_primitive->pad_list();
+  auto dilation = conv_primitive->dilation();
+  if (kernel_size == nullptr || stride == nullptr || dilation == nullptr) {
+    MS_LOG(ERROR) << "nullptr";
+    return nullptr;
+  }
+  conv_param->kernel_h_ = static_cast<int>(*(kernel_size->begin()));
+  conv_param->kernel_w_ = static_cast<int>(*(kernel_size->begin() + 1));
   conv_param->group_ = static_cast<int>(conv_primitive->group());
-  conv_param->stride_h_ = static_cast<int>(*(conv_primitive->stride()->begin()));
-  conv_param->stride_w_ = static_cast<int>(*(conv_primitive->stride()->begin() + 1));
+  conv_param->stride_h_ = static_cast<int>(*(stride->begin()));
+  conv_param->stride_w_ = static_cast<int>(*(stride->begin() + 1));
   switch (conv_primitive->pad_mode()) {
     case schema::PadMode_SAME:
       conv_param->pad_mode_ = Pad_same;
@@ -46,19 +59,19 @@ OpParameter *PopulateConvParameter(const void *prim) {
     default:
       conv_param->pad_mode_ = Pad_pad;
   }
-  if (conv_primitive->pad_list() == nullptr || conv_primitive->pad_list()->size() < 4) {
+  if (pad_list == nullptr || pad_list->size() < 4) {
     conv_param->pad_u_ = 0;
     conv_param->pad_d_ = 0;
     conv_param->pad_l_ = 0;
     conv_param->pad_r_ = 0;
   } else {
-    conv_param->pad_u_ = static_cast<int>(*(conv_primitive->pad_list()->begin()));
-    conv_param->pad_d_ = static_cast<int>(*(conv_primitive->pad_list()->begin() + 1));
-    conv_param->pad_l_ = static_cast<int>(*(conv_primitive->pad_list()->begin() + 2));
-    conv_param->pad_r_ = static_cast<int>(*(conv_primitive->pad_list()->begin() + 3));
+    conv_param->pad_u_ = static_cast<int>(*(pad_list->begin()));
+    conv_param->pad_d_ = static_cast<int>(*(pad_list->begin() + 1));
+    conv_param->pad_l_ = static_cast<int>(*(pad_list->begin() + 2));
+    conv_param->pad_r_ = static_cast<int>(*(pad_list->begin() + 3));
   }
-  conv_param->dilation_h_ = static_cast<int>(*(conv_primitive->dilation()->begin()));
-  conv_param->dilation_w_ = static_cast<int>(*(conv_primitive->dilation()->begin() + 1));
+  conv_param->dilation_h_ = static_cast<int>(*(dilation->begin()));
+  conv_param->dilation_w_ = static_cast<int>(*(dilation->begin() + 1));
   conv_param->input_channel_ = static_cast<int>(conv_primitive->in_channel());
   conv_param->output_channel_ = static_cast<int>(conv_primitive->out_channel());
   auto act_type = conv_primitive->activation_type();

mindspore/lite/src/ops/populate/crop_and_resize_populate.cc

@@ -20,16 +20,20 @@ namespace mindspore {
 namespace lite {
 namespace {
 OpParameter *PopulateCropAndResizeParameter(const void *prim) {
-  CropAndResizeParameter *crop_resize_param =
-    reinterpret_cast<CropAndResizeParameter *>(malloc(sizeof(CropAndResizeParameter)));
+  auto *crop_resize_param = reinterpret_cast<CropAndResizeParameter *>(malloc(sizeof(CropAndResizeParameter)));
   if (crop_resize_param == nullptr) {
     MS_LOG(ERROR) << "malloc CropAndResizeParameter failed.";
     return nullptr;
   }
   memset(crop_resize_param, 0, sizeof(CropAndResizeParameter));
   auto primitive = static_cast<const schema::Primitive *>(prim);
+  MS_ASSERT(primitive != nullptr);
   crop_resize_param->op_parameter_.type_ = primitive->value_type();
   auto param = primitive->value_as_CropAndResize();
+  if (param == nullptr) {
+    MS_LOG(ERROR) << "param is nullptr";
+    return nullptr;
+  }
   crop_resize_param->method_ = static_cast<int>(param->method());
   crop_resize_param->extrapolation_value_ = param->extrapolation_value();
   return reinterpret_cast<OpParameter *>(crop_resize_param);

mindspore/lite/src/ops/populate/crop_populate.cc

@@ -22,13 +22,22 @@ namespace lite {
 namespace {
 OpParameter *PopulateCropParameter(const void *prim) {
   auto primitive = static_cast<const schema::Primitive *>(prim);
+  MS_ASSERT(primitive != nullptr);
   auto crop_prim = primitive->value_as_Crop();
+  if (crop_prim == nullptr) {
+    MS_LOG(ERROR) << "crop_prim is nullptr";
+    return nullptr;
+  }
   auto param_offset = crop_prim->offsets();
+  if (param_offset == nullptr) {
+    MS_LOG(ERROR) << "param_offset is nullptr";
+    return nullptr;
+  }
   if (param_offset->size() > COMM_SHAPE_SIZE) {
     MS_LOG(ERROR) << "crop_param offset size(" << param_offset->size() << ") should <= " << COMM_SHAPE_SIZE;
     return nullptr;
   }
-  CropParameter *crop_param = reinterpret_cast<CropParameter *>(malloc(sizeof(CropParameter)));
+  auto *crop_param = reinterpret_cast<CropParameter *>(malloc(sizeof(CropParameter)));
   if (crop_param == nullptr) {
     MS_LOG(ERROR) << "malloc CropParameter failed.";
     return nullptr;

mindspore/lite/src/ops/populate/custom_extract_features_populate.cc

@@ -20,13 +20,14 @@ namespace mindspore {
 namespace lite {
 namespace {
 OpParameter *PopulateExtractFeaturesParameter(const void *prim) {
-  OpParameter *param = reinterpret_cast<OpParameter *>(malloc(sizeof(OpParameter)));
+  auto *param = reinterpret_cast<OpParameter *>(malloc(sizeof(OpParameter)));
   if (param == nullptr) {
     MS_LOG(ERROR) << "new OpParameter failed.";
     return nullptr;
   }
   memset(param, 0, sizeof(OpParameter));
   auto primitive = static_cast<const schema::Primitive *>(prim);
+  MS_ASSERT(primitive != nullptr);
   param->type_ = primitive->value_type();
   return param;
 }

mindspore/lite/src/ops/populate/custom_normalize_populate.cc

@@ -18,15 +18,15 @@ using mindspore::schema::PrimitiveType_CustomNormalize;
 
 namespace mindspore {
 namespace lite {
-
 OpParameter *PopulateCustomNormalizeParameter(const void *prim) {
-  OpParameter *param = reinterpret_cast<OpParameter *>(malloc(sizeof(OpParameter)));
+  auto *param = reinterpret_cast<OpParameter *>(malloc(sizeof(OpParameter)));
   if (param == nullptr) {
     MS_LOG(ERROR) << "new OpParameter failed.";
     return nullptr;
   }
   memset(param, 0, sizeof(OpParameter));
   auto primitive = static_cast<const schema::Primitive *>(prim);
+  MS_ASSERT(primitive != nullptr);
   param->type_ = primitive->value_type();
   return param;
 }

mindspore/lite/src/ops/populate/custom_predict_populate.cc

@@ -19,7 +19,6 @@ using mindspore::schema::PrimitiveType_CustomPredict;
 
 namespace mindspore {
 namespace lite {
-
 OpParameter *PopulateCustomPredictParameter(const void *prim) {
   PredictParameter *param = reinterpret_cast<PredictParameter *>(malloc(sizeof(PredictParameter)));
   if (param == nullptr) {
@@ -28,7 +27,12 @@ OpParameter *PopulateCustomPredictParameter(const void *prim) {
   }
   memset(param, 0, sizeof(PredictParameter));
   auto primitive = static_cast<const schema::Primitive *>(prim);
+  MS_ASSERT(primitive != nullptr);
   auto value = primitive->value_as_CustomPredict();
+  if (value == nullptr) {
+    MS_LOG(ERROR) << "value is nullptr";
+    return nullptr;
+  }
   param->op_parameter_.type_ = primitive->value_type();
   param->output_num = value->output_num();
   param->weight_threshold = value->weight_threshold();

mindspore/lite/src/ops/populate/deconv2d_populate.cc

@@ -20,24 +20,37 @@ using mindspore::schema::PrimitiveType_Conv2dTransposeFusion;
 
 namespace mindspore {
 namespace lite {
-
 OpParameter *PopulateDeconvParameter(const void *prim) {
-  ConvParameter *conv_param = reinterpret_cast<ConvParameter *>(malloc(sizeof(ConvParameter)));
+  auto *conv_param = reinterpret_cast<ConvParameter *>(malloc(sizeof(ConvParameter)));
   if (conv_param == nullptr) {
     MS_LOG(ERROR) << "malloc ConvParameter failed.";
     return nullptr;
   }
   memset(conv_param, 0, sizeof(ConvParameter));
   auto primitive = static_cast<const schema::Primitive *>(prim);
+  MS_ASSERT(primitive != nullptr);
   conv_param->op_parameter_.type_ = primitive->value_type();
   auto conv_primitive = primitive->value_as_Conv2dTransposeFusion();
-  conv_param->kernel_h_ = static_cast<int>(*(conv_primitive->kernel_size()->begin()));
-  conv_param->kernel_w_ = static_cast<int>(*(conv_primitive->kernel_size()->begin() + 1));
+  if (conv_primitive == nullptr) {
+    MS_LOG(ERROR) << "conv_primitive is nullptr";
+    return nullptr;
+  }
+  auto kernel_size = conv_primitive->kernel_size();
+  auto stride = conv_primitive->stride();
+  auto pad_list = conv_primitive->pad_list();
+  auto dilation = conv_primitive->dilation();
+  auto output_paddings = conv_primitive->output_paddings();
+  if (kernel_size == nullptr || stride == nullptr || dilation == nullptr || output_paddings == nullptr) {
+    MS_LOG(ERROR) << "nullptr";
+    return nullptr;
+  }
+  conv_param->kernel_h_ = static_cast<int>(*(kernel_size->begin()));
+  conv_param->kernel_w_ = static_cast<int>(*(kernel_size->begin() + 1));
   conv_param->group_ = static_cast<int>(conv_primitive->group());
-  conv_param->stride_h_ = static_cast<int>(*(conv_primitive->stride()->begin()));
-  conv_param->stride_w_ = static_cast<int>(*(conv_primitive->stride()->begin() + 1));
-  conv_param->output_padding_h_ = static_cast<int>(*(conv_primitive->output_paddings()->begin()));
-  conv_param->output_padding_w_ = static_cast<int>(*(conv_primitive->output_paddings()->begin() + 1));
+  conv_param->stride_h_ = static_cast<int>(*(stride->begin()));
+  conv_param->stride_w_ = static_cast<int>(*(stride->begin() + 1));
+  conv_param->output_padding_h_ = static_cast<int>(*(output_paddings->begin()));
+  conv_param->output_padding_w_ = static_cast<int>(*(output_paddings->begin() + 1));
   switch (conv_primitive->pad_mode()) {
     case schema::PadMode_SAME:
       conv_param->pad_mode_ = Pad_same;
@@ -48,19 +61,19 @@ OpParameter *PopulateDeconvParameter(const void *prim) {
     default:
       conv_param->pad_mode_ = Pad_pad;
   }
-  if (conv_primitive->pad_list() == nullptr || conv_primitive->pad_list()->size() < 4) {
+  if (pad_list == nullptr || pad_list->size() < 4) {
     conv_param->pad_u_ = 0;
     conv_param->pad_d_ = 0;
     conv_param->pad_l_ = 0;
     conv_param->pad_r_ = 0;
   } else {
-    conv_param->pad_u_ = static_cast<int>(*(conv_primitive->pad_list()->begin()));
-    conv_param->pad_d_ = static_cast<int>(*(conv_primitive->pad_list()->begin() + 1));
-    conv_param->pad_l_ = static_cast<int>(*(conv_primitive->pad_list()->begin() + 2));
-    conv_param->pad_r_ = static_cast<int>(*(conv_primitive->pad_list()->begin() + 3));
+    conv_param->pad_u_ = static_cast<int>(*(pad_list->begin()));
+    conv_param->pad_d_ = static_cast<int>(*(pad_list->begin() + 1));
+    conv_param->pad_l_ = static_cast<int>(*(pad_list->begin() + 2));
+    conv_param->pad_r_ = static_cast<int>(*(pad_list->begin() + 3));
   }
-  conv_param->dilation_h_ = static_cast<int>(*(conv_primitive->dilation()->begin()));
-  conv_param->dilation_w_ = static_cast<int>(*(conv_primitive->dilation()->begin() + 1));
+  conv_param->dilation_h_ = static_cast<int>(*(dilation->begin()));
+  conv_param->dilation_w_ = static_cast<int>(*(dilation->begin() + 1));
   conv_param->input_channel_ = static_cast<int>(conv_primitive->in_channel());
   conv_param->output_channel_ = static_cast<int>(conv_primitive->out_channel());
   auto act_type = conv_primitive->activation_type();

mindspore/lite/src/ops/populate/default_populate.cc

@@ -22,13 +22,14 @@
 namespace mindspore {
 namespace lite {
 OpParameter *DefaultPopulateParameter(const void *prim) {
-  OpParameter *param = static_cast<OpParameter *>(malloc(sizeof(OpParameter)));
+  auto *param = static_cast<OpParameter *>(malloc(sizeof(OpParameter)));
   if (param == nullptr) {
     MS_LOG(ERROR) << "Malloc OpParameter failed.";
     return nullptr;
   }
   memset(param, 0, sizeof(OpParameter));
   auto *primitive = static_cast<const schema::Primitive *>(prim);
+  MS_ASSERT(primitive != nullptr);
   param->type_ = primitive->value_type();
   return param;
 }

mindspore/lite/src/ops/populate/depth_to_space_populate.cc

@@ -21,15 +21,19 @@ namespace mindspore {
 namespace lite {
 namespace {
 OpParameter *PopulateDepthToSpaceParameter(const void *prim) {
-  DepthToSpaceParameter *depth_space_param =
-    reinterpret_cast<DepthToSpaceParameter *>(malloc(sizeof(DepthToSpaceParameter)));
+  auto *depth_space_param = reinterpret_cast<DepthToSpaceParameter *>(malloc(sizeof(DepthToSpaceParameter)));
   if (depth_space_param == nullptr) {
     MS_LOG(ERROR) << "malloc DepthToSpaceParameter failed.";
     return nullptr;
   }
   memset(depth_space_param, 0, sizeof(DepthToSpaceParameter));
   auto primitive = static_cast<const schema::Primitive *>(prim);
+  MS_ASSERT(primitive != nullptr);
   auto param = primitive->value_as_DepthToSpace();
+  if (param == nullptr) {
+    MS_LOG(ERROR) << "param is nullptr";
+    return nullptr;
+  }
   depth_space_param->op_parameter_.type_ = primitive->value_type();
   depth_space_param->block_size_ = param->block_size();
   return reinterpret_cast<OpParameter *>(depth_space_param);

mindspore/lite/src/ops/populate/depthwise_conv2d_populate.cc

@@ -18,9 +18,8 @@
 
 namespace mindspore {
 namespace lite {
-
 OpParameter *PopulateConvDwParameter(const void *primitive) {
-  ConvParameter *conv_param = reinterpret_cast<ConvParameter *>(malloc(sizeof(ConvParameter)));
+  auto *conv_param = reinterpret_cast<ConvParameter *>(malloc(sizeof(ConvParameter)));
   if (conv_param == nullptr) {
     MS_LOG(ERROR) << "malloc ConvParameter failed.";
     return nullptr;

mindspore/lite/src/ops/populate/detection_post_process_populate.cc

@@ -21,7 +21,7 @@ namespace mindspore {
 namespace lite {
 namespace {
 OpParameter *PopulateDetectionPostProcessParameter(const void *prim) {
-  DetectionPostProcessParameter *detection_post_process_parameter =
+  auto *detection_post_process_parameter =
     reinterpret_cast<DetectionPostProcessParameter *>(malloc(sizeof(DetectionPostProcessParameter)));
   if (detection_post_process_parameter == nullptr) {
     MS_LOG(ERROR) << "malloc EluParameter failed.";
@@ -29,12 +29,22 @@ OpParameter *PopulateDetectionPostProcessParameter(const void *prim) {
   }
   memset(detection_post_process_parameter, 0, sizeof(DetectionPostProcessParameter));
   auto primitive = static_cast<const schema::Primitive *>(prim);
+  MS_ASSERT(primitive != nullptr);
   detection_post_process_parameter->op_parameter_.type_ = primitive->value_type();
   auto param = primitive->value_as_DetectionPostProcess();
-  detection_post_process_parameter->h_scale_ = *(param->scale()->begin());
-  detection_post_process_parameter->w_scale_ = *(param->scale()->begin() + 1);
-  detection_post_process_parameter->x_scale_ = *(param->scale()->begin() + 2);
-  detection_post_process_parameter->y_scale_ = *(param->scale()->begin() + 3);
+  if (param == nullptr) {
+    MS_LOG(ERROR) << "param is nullptr";
+    return nullptr;
+  }
+  auto scale = param->scale();
+  if (scale == nullptr) {
+    MS_LOG(ERROR) << "scale is nullptr";
+    return nullptr;
+  }
+  detection_post_process_parameter->h_scale_ = *(scale->begin());
+  detection_post_process_parameter->w_scale_ = *(scale->begin() + 1);
+  detection_post_process_parameter->x_scale_ = *(scale->begin() + 2);
+  detection_post_process_parameter->y_scale_ = *(scale->begin() + 3);
   detection_post_process_parameter->nms_iou_threshold_ = param->nms_iou_threshold();
   detection_post_process_parameter->nms_score_threshold_ = param->nms_score_threshold();
   detection_post_process_parameter->max_detections_ = param->max_detections();

mindspore/lite/src/ops/populate/div_populate.cc

@@ -18,9 +18,8 @@
 using mindspore::schema::PrimitiveType_DivFusion;
 namespace mindspore {
 namespace lite {
-
 OpParameter *PopulateDivParameter(const void *prim) {
-  ArithmeticParameter *param = PopulateArithmeticCommonPara(prim);
+  auto *param = PopulateArithmeticCommonPara(prim);
   if (param == nullptr) {
     MS_LOG(ERROR) << "PopulateArithmeticCommonPara failed.";
     return nullptr;

mindspore/lite/src/ops/populate/eltwise_populate.cc

@@ -27,7 +27,13 @@ OpParameter *PopulateEltwiseParameter(const void *prim) {
     return nullptr;
   }
   auto primitive = static_cast<const schema::Primitive *>(prim);
-  param->eltwise_mode_ = primitive->value_as_Eltwise()->mode();
+  MS_ASSERT(primitive != nullptr);
+  auto eltwise_param = primitive->value_as_Eltwise();
+  if (eltwise_param == nullptr) {
+    MS_LOG(ERROR) << "eltwise_param is nullptr";
+    return nullptr;
+  }
+  param->eltwise_mode_ = eltwise_param->mode();
   return reinterpret_cast<OpParameter *>(param);
 }
 }  // namespace

mindspore/lite/src/ops/populate/elu_populate.cc

@@ -21,15 +21,20 @@ namespace mindspore {
 namespace lite {
 namespace {
 OpParameter *PopulateEluParameter(const void *prim) {
-  EluParameter *elu_parameter = reinterpret_cast<EluParameter *>(malloc(sizeof(EluParameter)));
+  auto *elu_parameter = reinterpret_cast<EluParameter *>(malloc(sizeof(EluParameter)));
   if (elu_parameter == nullptr) {
     MS_LOG(ERROR) << "malloc EluParameter failed.";
     return nullptr;
   }
   memset(elu_parameter, 0, sizeof(EluParameter));
   auto primitive = static_cast<const schema::Primitive *>(prim);
+  MS_ASSERT(primitive != nullptr);
   elu_parameter->op_parameter_.type_ = primitive->value_type();
   auto param = primitive->value_as_Elu();
+  if (param == nullptr) {
+    MS_LOG(ERROR) << "param is nullptr";
+    return nullptr;
+  }
   elu_parameter->alpha_ = param->alpha();
   return reinterpret_cast<OpParameter *>(elu_parameter);
 }

mindspore/lite/src/ops/populate/embedding_lookup_populate.cc

@@ -21,8 +21,7 @@ namespace mindspore {
 namespace lite {
 
 OpParameter *PopulateEmbeddingLookupParameter(const void *prim) {
-  EmbeddingLookupParameter *param =
-    reinterpret_cast<EmbeddingLookupParameter *>(malloc(sizeof(EmbeddingLookupParameter)));
+  auto *param = reinterpret_cast<EmbeddingLookupParameter *>(malloc(sizeof(EmbeddingLookupParameter)));
   if (param == nullptr) {
     MS_LOG(ERROR) << "malloc EmbeddingLookupParameter failed.";
     return nullptr;
@@ -30,7 +29,12 @@ OpParameter *PopulateEmbeddingLookupParameter(const void *prim) {
   memset(param, 0, sizeof(EmbeddingLookupParameter));
 
   auto primitive = static_cast<const schema::Primitive *>(prim);
+  MS_ASSERT(primitive != nullptr);
   auto value = primitive->value_as_EmbeddingLookupFusion();
+  if (value == nullptr) {
+    MS_LOG(ERROR) << "value is nullptr";
+    return nullptr;
+  }
   param->op_parameter_.type_ = primitive->value_type();
   param->max_norm_ = value->max_norm();
   if (param->max_norm_ < 0) {

mindspore/lite/src/ops/populate/exp_populate.cc

@@ -20,7 +20,7 @@ using mindspore::schema::PrimitiveType_ExpFusion;
 namespace mindspore {
 namespace lite {
 OpParameter *PopulateExpParameter(const void *prim) {
-  ExpParameter *exp_parameter = reinterpret_cast<ExpParameter *>(malloc(sizeof(ExpParameter)));
+  auto *exp_parameter = reinterpret_cast<ExpParameter *>(malloc(sizeof(ExpParameter)));
   if (exp_parameter == nullptr) {
     MS_LOG(ERROR) << "malloc ExpParameter failed.";
     return nullptr;
@@ -28,7 +28,12 @@ OpParameter *PopulateExpParameter(const void *prim) {
   memset(exp_parameter, 0, sizeof(ExpParameter));
 
   auto primitive = static_cast<const schema::Primitive *>(prim);
+  MS_ASSERT(primitive != nullptr);
   auto value = primitive->value_as_ExpFusion();
+  if (value == nullptr) {
+    MS_LOG(ERROR) << "value is nullptr";
+    return nullptr;
+  }
   exp_parameter->op_parameter_.type_ = primitive->value_type();
   exp_parameter->base_ = value->base();
   exp_parameter->scale_ = value->scale();

mindspore/lite/src/ops/populate/expand_dims_populate.cc

@@ -20,13 +20,14 @@ namespace mindspore {
 namespace lite {
 namespace {
 OpParameter *PopulateExpandDimsParameter(const void *prim) {
-  OpParameter *expand_param = reinterpret_cast<OpParameter *>(malloc(sizeof(OpParameter)));
+  auto *expand_param = reinterpret_cast<OpParameter *>(malloc(sizeof(OpParameter)));
   if (expand_param == nullptr) {
     MS_LOG(ERROR) << "malloc ExpandDimsParameter failed.";
     return nullptr;
   }
   memset(expand_param, 0, sizeof(OpParameter));
   auto primitive = static_cast<const schema::Primitive *>(prim);
+  MS_ASSERT(primitive != nullptr);
   expand_param->type_ = primitive->value_type();
   return reinterpret_cast<OpParameter *>(expand_param);
 }

mindspore/lite/src/ops/populate/fill_populate.cc

@@ -20,13 +20,14 @@ namespace mindspore {
 namespace lite {
 namespace {
 OpParameter *PopulateFillParameter(const void *prim) {
-  OpParameter *fill_param = reinterpret_cast<OpParameter *>(malloc(sizeof(OpParameter)));
+  auto *fill_param = reinterpret_cast<OpParameter *>(malloc(sizeof(OpParameter)));
   if (fill_param == nullptr) {
     MS_LOG(ERROR) << "malloc FillParameter failed.";
     return nullptr;
   }
   memset(fill_param, 0, sizeof(OpParameter));
   auto primitive = static_cast<const schema::Primitive *>(prim);
+  MS_ASSERT(primitive != nullptr);
   fill_param->type_ = primitive->value_type();
   return reinterpret_cast<OpParameter *>(fill_param);
 }

mindspore/lite/src/ops/populate/flatten_populate.cc

@@ -19,7 +19,7 @@ using mindspore::schema::PrimitiveType_Flatten;
 namespace mindspore {
 namespace lite {
 OpParameter *PopulateFlattenParameter(const void *prim) {
-  OpParameter *flatten_param = reinterpret_cast<OpParameter *>(malloc(sizeof(OpParameter)));
+  auto *flatten_param = reinterpret_cast<OpParameter *>(malloc(sizeof(OpParameter)));
   if (flatten_param == nullptr) {
     MS_LOG(ERROR) << "malloc FlattenParameter failed.";
     return nullptr;
@@ -27,6 +27,7 @@ OpParameter *PopulateFlattenParameter(const void *prim) {
   memset(flatten_param, 0, sizeof(OpParameter));
 
   auto primitive = static_cast<const schema::Primitive *>(prim);
+  MS_ASSERT(primitive != nullptr);
   flatten_param->type_ = primitive->value_type();
   return reinterpret_cast<OpParameter *>(flatten_param);
 }

mindspore/lite/src/ops/populate/full_connection_populate.cc

@@ -21,15 +21,20 @@ namespace mindspore {
 namespace lite {
 namespace {
 OpParameter *PopulateFullconnectionParameter(const void *prim) {
-  MatMulParameter *matmul_param = reinterpret_cast<MatMulParameter *>(malloc(sizeof(MatMulParameter)));
+  auto *matmul_param = reinterpret_cast<MatMulParameter *>(malloc(sizeof(MatMulParameter)));
   if (matmul_param == nullptr) {
     MS_LOG(ERROR) << "malloc MatMulParameter failed.";
     return nullptr;
   }
   memset(matmul_param, 0, sizeof(MatMulParameter));
   auto *primitive = static_cast<const schema::Primitive *>(prim);
+  MS_ASSERT(primitive != nullptr);
   matmul_param->op_parameter_.type_ = primitive->value_type();
   auto full_conn_prim = primitive->value_as_FullConnection();
+  if (full_conn_prim == nullptr) {
+    MS_LOG(ERROR) << "full_conn_prim is nullptr";
+    return nullptr;
+  }
   matmul_param->b_transpose_ = true;
   matmul_param->a_transpose_ = false;
   matmul_param->has_bias_ = full_conn_prim->has_bias();

mindspore/lite/src/ops/populate/fused_batchnorm_populate.cc

@@ -19,16 +19,20 @@ using mindspore::schema::PrimitiveType_FusedBatchNorm;
 
 namespace mindspore {
 namespace lite {
-
 OpParameter *PopulateFusedBatchNorm(const void *prim) {
-  BatchNormParameter *batch_norm_param = reinterpret_cast<BatchNormParameter *>(malloc(sizeof(BatchNormParameter)));
+  auto *batch_norm_param = reinterpret_cast<BatchNormParameter *>(malloc(sizeof(BatchNormParameter)));
   if (batch_norm_param == nullptr) {
     MS_LOG(ERROR) << "malloc BatchNormParameter failed.";
     return nullptr;
   }
   memset(batch_norm_param, 0, sizeof(BatchNormParameter));
   auto primitive = static_cast<const schema::Primitive *>(prim);
+  MS_ASSERT(primitive != nullptr);
   auto value = primitive->value_as_FusedBatchNorm();
+  if (value == nullptr) {
+    MS_LOG(ERROR) << "value is nullptr";
+    return nullptr;
+  }
   batch_norm_param->op_parameter_.type_ = primitive->value_type();
   batch_norm_param->epsilon_ = value->epsilon();
   batch_norm_param->momentum_ = value->momentum();

mindspore/lite/src/ops/populate/gather_nd_populate.cc

@@ -21,13 +21,14 @@ namespace mindspore {
 namespace lite {
 namespace {
 OpParameter *PopulateGatherNdParameter(const void *prim) {
-  GatherNdParameter *gather_nd_param = reinterpret_cast<GatherNdParameter *>(malloc(sizeof(GatherNdParameter)));
+  auto *gather_nd_param = reinterpret_cast<GatherNdParameter *>(malloc(sizeof(GatherNdParameter)));
   if (gather_nd_param == nullptr) {
     MS_LOG(ERROR) << "malloc GatherNdParameter failed.";
     return nullptr;
   }
   memset(gather_nd_param, 0, sizeof(GatherNdParameter));
   auto primitive = static_cast<const schema::Primitive *>(prim);
+  MS_ASSERT(primitive != nullptr);
   gather_nd_param->op_parameter_.type_ = primitive->value_type();
   return reinterpret_cast<OpParameter *>(gather_nd_param);
 }

mindspore/lite/src/ops/populate/gather_populate.cc

@@ -21,13 +21,14 @@ namespace mindspore {
 namespace lite {
 namespace {
 OpParameter *PopulateGatherParameter(const void *prim) {
-  GatherParameter *gather_param = reinterpret_cast<GatherParameter *>(malloc(sizeof(GatherParameter)));
+  auto *gather_param = reinterpret_cast<GatherParameter *>(malloc(sizeof(GatherParameter)));
   if (gather_param == nullptr) {
     MS_LOG(ERROR) << "malloc GatherParameter failed.";
     return nullptr;
   }
   memset(gather_param, 0, sizeof(GatherParameter));
   auto primitive = static_cast<const schema::Primitive *>(prim);
+  MS_ASSERT(primitive != nullptr);
   gather_param->op_parameter_.type_ = primitive->value_type();
 
   return reinterpret_cast<OpParameter *>(gather_param);

mindspore/lite/src/ops/populate/gru_populate.cc

@@ -21,18 +21,19 @@ namespace mindspore {
 namespace lite {
 namespace {
 OpParameter *PopulateGruParameter(const void *prim) {
-  GruParameter *gru_param = reinterpret_cast<GruParameter *>(malloc(sizeof(GruParameter)));
+  auto *gru_param = reinterpret_cast<GruParameter *>(malloc(sizeof(GruParameter)));
   if (gru_param == nullptr) {
     MS_LOG(ERROR) << "malloc GruParameter failed.";
     return nullptr;
   }
   memset(gru_param, 0, sizeof(GruParameter));
   auto *primitive = static_cast<const schema::Primitive *>(prim);
+  MS_ASSERT(primitive != nullptr);
   gru_param->op_parameter_.type_ = primitive->value_type();
   auto param = primitive->value_as_GRU();
   if (param == nullptr) {
     free(gru_param);
-    MS_LOG(ERROR) << "get Gru param nullptr.";
+    MS_LOG(ERROR) << "param is nullptr.";
     return nullptr;
   }
   gru_param->bidirectional_ = param->bidirectional();

mindspore/lite/src/ops/populate/hashtable_lookup_populate.cc

@@ -18,15 +18,15 @@ using mindspore::schema::PrimitiveType_HashtableLookup;
 
 namespace mindspore {
 namespace lite {
-
 OpParameter *PopulateHashtableLookupParameter(const void *prim) {
-  OpParameter *param = reinterpret_cast<OpParameter *>(malloc(sizeof(OpParameter)));
+  auto *param = reinterpret_cast<OpParameter *>(malloc(sizeof(OpParameter)));
   if (param == nullptr) {
     MS_LOG(ERROR) << "new OpParameter failed.";
     return nullptr;
   }
   memset(param, 0, sizeof(OpParameter));
   auto primitive = static_cast<const schema::Primitive *>(prim);
+  MS_ASSERT(primitive != nullptr);
   param->type_ = primitive->value_type();
   return param;
 }

mindspore/lite/src/ops/populate/instance_norm_populate.cc

@@ -20,8 +20,7 @@ using mindspore::schema::PrimitiveType_InstanceNorm;
 namespace mindspore {
 namespace lite {
 OpParameter *PopulateInstanceNormParameter(const void *prim) {
-  InstanceNormParameter *instance_norm_param =
-    reinterpret_cast<InstanceNormParameter *>(malloc(sizeof(InstanceNormParameter)));
+  auto *instance_norm_param = reinterpret_cast<InstanceNormParameter *>(malloc(sizeof(InstanceNormParameter)));
   if (instance_norm_param == nullptr) {
     MS_LOG(ERROR) << "malloc InstanceNormParameter failed.";
     return nullptr;
@@ -29,7 +28,12 @@ OpParameter *PopulateInstanceNormParameter(const void *prim) {
   memset(instance_norm_param, 0, sizeof(InstanceNormParameter));
 
   auto primitive = static_cast<const schema::Primitive *>(prim);
+  MS_ASSERT(primitive != nullptr);
   auto value = primitive->value_as_InstanceNorm();
+  if (value == nullptr) {
+    MS_LOG(ERROR) << "value is nullptr";
+    return nullptr;
+  }
   instance_norm_param->op_parameter_.type_ = primitive->value_type();
   instance_norm_param->epsilon_ = value->epsilon();
   return reinterpret_cast<OpParameter *>(instance_norm_param);

mindspore/lite/src/ops/populate/l2_norm_populate.cc

@@ -20,9 +20,8 @@ using mindspore::schema::PrimitiveType_L2NormalizeFusion;
 
 namespace mindspore {
 namespace lite {
-
 OpParameter *PopulateL2NormParameter(const void *prim) {
-  L2NormParameter *l2_norm_parameter = reinterpret_cast<L2NormParameter *>(malloc(sizeof(L2NormParameter)));
+  auto *l2_norm_parameter = reinterpret_cast<L2NormParameter *>(malloc(sizeof(L2NormParameter)));
   if (l2_norm_parameter == nullptr) {
     MS_LOG(ERROR) << "malloc L2NormParameter failed.";
     return nullptr;
@@ -30,10 +29,19 @@ OpParameter *PopulateL2NormParameter(const void *prim) {
   memset(l2_norm_parameter, 0, sizeof(L2NormParameter));
 
   auto primitive = static_cast<const schema::Primitive *>(prim);
+  MS_ASSERT(primitive != nullptr);
   auto value = primitive->value_as_L2NormalizeFusion();
+  if (value == nullptr) {
+    MS_LOG(ERROR) << "value is nullptr";
+    return nullptr;
+  }
   l2_norm_parameter->op_parameter_.type_ = primitive->value_type();
 
   auto axis_vec = value->axis();
+  if (axis_vec == nullptr) {
+    MS_LOG(ERROR) << "axis_vec is nullptr";
+    return nullptr;
+  }
   l2_norm_parameter->axis_num_ = axis_vec->size();
 
   MS_ASSERT(axis_vec->size() < 8);

mindspore/lite/src/ops/populate/layer_norm_grad_populate.cc

@@ -28,8 +28,13 @@ OpParameter *PopulateLayerNormGradParameter(const void *prim) {
   }
   memset(layer_norm_grad_parameter, 0, sizeof(LayerNormGradParameter));
   auto *primitive = static_cast<const schema::Primitive *>(prim);
+  MS_ASSERT(primitive != nullptr);
   layer_norm_grad_parameter->op_parameter_.type_ = primitive->value_type();
   auto param = primitive->value_as_LayerNormGrad();
+  if (param == nullptr) {
+    MS_LOG(ERROR) << "param is nullptr";
+    return nullptr;
+  }
   layer_norm_grad_parameter->begin_norm_axis_ = param->begin_norm_axis();
   layer_norm_grad_parameter->begin_params_axis_ = param->begin_params_axis();
   return reinterpret_cast<OpParameter *>(layer_norm_grad_parameter);

mindspore/lite/src/ops/populate/layer_norm_populate.cc

@@ -27,8 +27,13 @@ OpParameter *PopulateLayerNormParameter(const void *prim) {
   }
   memset(layer_norm_parameter, 0, sizeof(LayerNormParameter));
   auto *primitive = static_cast<const schema::Primitive *>(prim);
+  MS_ASSERT(primitive != nullptr);
   layer_norm_parameter->op_parameter_.type_ = primitive->value_type();
   auto param = primitive->value_as_LayerNormFusion();
+  if (param == nullptr) {
+    MS_LOG(ERROR) << "param is nullptr";
+    return nullptr;
+  }
   layer_norm_parameter->epsilon_ = param->epsilon();
   layer_norm_parameter->elementwise_affine_ = param->elementwise_affine();
   layer_norm_parameter->begin_norm_axis_ = static_cast<int>(param->begin_norm_axis());

mindspore/lite/src/ops/populate/local_response_normalization_populate.cc

@@ -19,17 +19,20 @@ using mindspore::schema::PrimitiveType_LRN;
 
 namespace mindspore {
 namespace lite {
-
 OpParameter *PopulateLocalResponseNormParameter(const void *prim) {
-  LocalResponseNormParameter *lrn_param =
-    reinterpret_cast<LocalResponseNormParameter *>(malloc(sizeof(LocalResponseNormParameter)));
+  auto *lrn_param = reinterpret_cast<LocalResponseNormParameter *>(malloc(sizeof(LocalResponseNormParameter)));
   if (lrn_param == nullptr) {
     MS_LOG(ERROR) << "malloc LocalResponseNormParameter failed.";
     return nullptr;
   }
   memset(lrn_param, 0, sizeof(LocalResponseNormParameter));
   auto primitive = static_cast<const schema::Primitive *>(prim);
+  MS_ASSERT(primitive != nullptr);
   auto value = primitive->value_as_LRN();
+  if (value == nullptr) {
+    MS_LOG(ERROR) << "value is nullptr";
+    return nullptr;
+  }
   lrn_param->op_parameter_.type_ = primitive->value_type();
   lrn_param->depth_radius_ = value->depth_radius();
   lrn_param->bias_ = value->bias();

mindspore/lite/src/ops/populate/log_softmax_populate.cc

@@ -21,15 +21,20 @@ namespace mindspore {
 namespace lite {
 namespace {
 OpParameter *PopulateLogSoftmaxParameter(const void *prim) {
-  SoftmaxParameter *log_softmax_param = reinterpret_cast<SoftmaxParameter *>(malloc(sizeof(SoftmaxParameter)));
+  auto *log_softmax_param = reinterpret_cast<SoftmaxParameter *>(malloc(sizeof(SoftmaxParameter)));
   if (log_softmax_param == nullptr) {
     MS_LOG(ERROR) << "malloc LogSoftmaxParameter failed.";
     return nullptr;
   }
   memset(log_softmax_param, 0, sizeof(SoftmaxParameter));
   auto primitive = static_cast<const schema::Primitive *>(prim);
+  MS_ASSERT(primitive != nullptr);
   log_softmax_param->op_parameter_.type_ = primitive->value_type();
   auto prim_log_softmax = primitive->value_as_LogSoftmax();
+  if (prim_log_softmax == nullptr) {
+    MS_LOG(ERROR) << "prim_log_softmax is nullptr";
+    return nullptr;
+  }
   log_softmax_param->axis_ = prim_log_softmax->axis();
   return reinterpret_cast<OpParameter *>(log_softmax_param);
 }

mindspore/lite/src/ops/populate/lsh_projection_populate.cc

@@ -19,10 +19,8 @@ using mindspore::schema::PrimitiveType_LshProjection;
 
 namespace mindspore {
 namespace lite {
-
 OpParameter *PopulateLshProjectionParameter(const void *prim) {
-  LshProjectionParameter *lsh_project_param =
-    reinterpret_cast<LshProjectionParameter *>(malloc(sizeof(LshProjectionParameter)));
+  auto *lsh_project_param = reinterpret_cast<LshProjectionParameter *>(malloc(sizeof(LshProjectionParameter)));
   if (lsh_project_param == nullptr) {
     MS_LOG(ERROR) << "malloc LshProjectionParameter failed.";
     return nullptr;
@@ -30,7 +28,12 @@ OpParameter *PopulateLshProjectionParameter(const void *prim) {
   memset(lsh_project_param, 0, sizeof(LshProjectionParameter));
 
   auto primitive = static_cast<const schema::Primitive *>(prim);
+  MS_ASSERT(primitive != nullptr);
   auto value = primitive->value_as_LshProjection();
+  if (value == nullptr) {
+    MS_LOG(ERROR) << "value is nullptr";
+    return nullptr;
+  }
   lsh_project_param->op_parameter_.type_ = primitive->value_type();
   lsh_project_param->lsh_type_ = value->type();
   return reinterpret_cast<OpParameter *>(lsh_project_param);

mindspore/lite/src/ops/populate/lstm_populate.cc

@@ -21,13 +21,14 @@ namespace mindspore {
 namespace lite {
 namespace {
 OpParameter *PopulateLstmParameter(const void *prim) {
-  LstmParameter *lstm_param = reinterpret_cast<LstmParameter *>(malloc(sizeof(LstmParameter)));
+  auto *lstm_param = reinterpret_cast<LstmParameter *>(malloc(sizeof(LstmParameter)));
   if (lstm_param == nullptr) {
     MS_LOG(ERROR) << "malloc LstmParameter failed.";
     return nullptr;
   }
   memset(lstm_param, 0, sizeof(LstmParameter));
   auto primitive = static_cast<const schema::Primitive *>(prim);
+  MS_ASSERT(primitive != nullptr);
   lstm_param->op_parameter_.type_ = primitive->value_type();
   auto param = primitive->value_as_LSTM();
   if (param == nullptr) {

mindspore/lite/src/ops/populate/matmul_populate.cc

@@ -18,16 +18,20 @@
 using mindspore::schema::PrimitiveType_MatMul;
 namespace mindspore {
 namespace lite {
-
 OpParameter *PopulateMatMulParameter(const void *prim) {
-  MatMulParameter *matmul_param = reinterpret_cast<MatMulParameter *>(malloc(sizeof(MatMulParameter)));
+  auto *matmul_param = reinterpret_cast<MatMulParameter *>(malloc(sizeof(MatMulParameter)));
   if (matmul_param == nullptr) {
     MS_LOG(ERROR) << "malloc MatMulParameter failed.";
     return nullptr;
   }
   memset(matmul_param, 0, sizeof(MatMulParameter));
   auto primitive = static_cast<const schema::Primitive *>(prim);
+  MS_ASSERT(primitive != nullptr);
   auto value = primitive->value_as_MatMul();
+  if (value == nullptr) {
+    MS_LOG(ERROR) << "value is nullptr";
+    return nullptr;
+  }
   matmul_param->op_parameter_.type_ = primitive->value_type();
   matmul_param->b_transpose_ = value->transpose_b();
   matmul_param->a_transpose_ = value->transpose_a();

mindspore/lite/src/ops/populate/merge_populate.cc

@@ -18,15 +18,15 @@ using mindspore::schema::PrimitiveType_Merge;
 
 namespace mindspore {
 namespace lite {
-
 OpParameter *PopulateMergeParameter(const void *prim) {
-  OpParameter *merge_parameter = reinterpret_cast<OpParameter *>(malloc(sizeof(OpParameter)));
+  auto *merge_parameter = reinterpret_cast<OpParameter *>(malloc(sizeof(OpParameter)));
   if (merge_parameter == nullptr) {
     MS_LOG(ERROR) << "malloc Merge parameter failed.";
     return nullptr;
   }
   memset(merge_parameter, 0, sizeof(OpParameter));
   auto primitive = static_cast<const schema::Primitive *>(prim);
+  MS_ASSERT(primitive != nullptr);
   merge_parameter->type_ = primitive->value_type();
   return reinterpret_cast<OpParameter *>(merge_parameter);
 }

mindspore/lite/src/ops/populate/mfcc_populate.cc

@@ -21,15 +21,20 @@ namespace mindspore {
 namespace lite {
 namespace {
 OpParameter *PopulateMfccParameter(const void *prim) {
-  MfccParameter *arg_param = reinterpret_cast<MfccParameter *>(malloc(sizeof(MfccParameter)));
+  auto *arg_param = reinterpret_cast<MfccParameter *>(malloc(sizeof(MfccParameter)));
   if (arg_param == nullptr) {
     MS_LOG(ERROR) << "malloc MfccParameter failed.";
     return nullptr;
   }
   memset(arg_param, 0, sizeof(MfccParameter));
   auto *primitive = static_cast<const schema::Primitive *>(prim);
+  MS_ASSERT(primitive != nullptr);
   arg_param->op_parameter_.type_ = primitive->value_type();
   auto param = primitive->value_as_Mfcc();
+  if (param == nullptr) {
+    MS_LOG(ERROR) << "param is nullptr";
+    return nullptr;
+  }
   arg_param->dct_coeff_num_ = param->dct_coeff_num();
   return reinterpret_cast<OpParameter *>(arg_param);
 }

mindspore/lite/src/ops/populate/mul_populate.cc

@@ -28,6 +28,7 @@ OpParameter *PopulateMulParameter(const void *prim) {
     return nullptr;
   }
   auto *primitive = static_cast<const schema::Primitive *>(prim);
+  MS_ASSERT(primitive != nullptr);
   param->op_parameter_.type_ = primitive->value_type();
   return reinterpret_cast<OpParameter *>(param);
 }

mindspore/lite/src/ops/populate/non_max_suppression_populate.cc

@@ -19,16 +19,20 @@ using mindspore::schema::PrimitiveType_NonMaxSuppression;
 
 namespace mindspore {
 namespace lite {
-
 OpParameter *PopulateNonMaxSuppressionParameter(const void *prim) {
-  NMSParameter *param = reinterpret_cast<NMSParameter *>(malloc(sizeof(NMSParameter)));
+  auto *param = reinterpret_cast<NMSParameter *>(malloc(sizeof(NMSParameter)));
   if (param == nullptr) {
     MS_LOG(ERROR) << "malloc param failed.";
     return nullptr;
   }
   memset(param, 0, sizeof(NMSParameter));
   auto primitive = static_cast<const schema::Primitive *>(prim);
+  MS_ASSERT(primitive != nullptr);
   auto value = primitive->value_as_NonMaxSuppression();
+  if (value == nullptr) {
+    MS_LOG(ERROR) << "value is nullptr";
+    return nullptr;
+  }
   param->op_parameter_.type_ = primitive->value_type();
   param->center_point_box_ = value->center_point_box();
   return reinterpret_cast<OpParameter *>(param);

mindspore/lite/src/ops/populate/one_hot_populate.cc

@@ -19,9 +19,8 @@ using mindspore::schema::PrimitiveType_OneHot;
 
 namespace mindspore {
 namespace lite {
-
 OpParameter *PopulateOneHotParameter(const void *prim) {
-  OneHotParameter *one_hot_param = reinterpret_cast<OneHotParameter *>(malloc(sizeof(OneHotParameter)));
+  auto *one_hot_param = reinterpret_cast<OneHotParameter *>(malloc(sizeof(OneHotParameter)));
   if (one_hot_param == nullptr) {
     MS_LOG(ERROR) << "malloc OneHotParameter failed.";
     return nullptr;
@@ -29,7 +28,12 @@ OpParameter *PopulateOneHotParameter(const void *prim) {
   memset(one_hot_param, 0, sizeof(OneHotParameter));
 
   auto primitive = static_cast<const schema::Primitive *>(prim);
+  MS_ASSERT(primitive != nullptr);
   auto value = primitive->value_as_OneHot();
+  if (value == nullptr) {
+    MS_LOG(ERROR) << "value is nullptr";
+    return nullptr;
+  }
   one_hot_param->op_parameter_.type_ = primitive->value_type();
   one_hot_param->axis_ = value->axis();
   return reinterpret_cast<OpParameter *>(one_hot_param);

mindspore/lite/src/ops/populate/oneslike_populate.cc

@@ -19,13 +19,14 @@ using mindspore::schema::PrimitiveType_OnesLike;
 namespace mindspore {
 namespace lite {
 OpParameter *PopulateOnesLikeParameter(const void *prim) {
-  OpParameter *param = reinterpret_cast<OpParameter *>(malloc(sizeof(OpParameter)));
+  auto *param = reinterpret_cast<OpParameter *>(malloc(sizeof(OpParameter)));
   if (param == nullptr) {
     MS_LOG(ERROR) << "malloc OnesLike Parameter failed.";
     return nullptr;
   }
   memset(param, 0, sizeof(OpParameter));
   auto primitive = static_cast<const schema::Primitive *>(prim);
+  MS_ASSERT(primitive != nullptr);
   param->type_ = primitive->value_type();
   return param;
 }

mindspore/lite/src/ops/populate/p_relu_populate.cc

@@ -19,7 +19,6 @@ using mindspore::schema::PrimitiveType_PReLUFusion;
 
 namespace mindspore {
 namespace lite {
-
 OpParameter *PopulatePReLUParameter(const void *prim) {
   PReluParameter *param = reinterpret_cast<PReluParameter *>(malloc(sizeof(PReluParameter)));
   if (param == nullptr) {
@@ -28,7 +27,12 @@ OpParameter *PopulatePReLUParameter(const void *prim) {
   }
   memset(param, 0, sizeof(PReluParameter));
   auto primitive = static_cast<const schema::Primitive *>(prim);
+  MS_ASSERT(primitive != nullptr);
   auto value = primitive->value_as_PReLUFusion();
+  if (value == nullptr) {
+    MS_LOG(ERROR) << "value is nullptr";
+    return nullptr;
+  }
   param->op_parameter_.type_ = primitive->value_type();
   param->channelShared = value->channel_shared();
   return reinterpret_cast<OpParameter *>(param);

mindspore/lite/src/ops/populate/pad_populate.cc

@@ -19,16 +19,20 @@ using mindspore::schema::PrimitiveType_PadFusion;
 
 namespace mindspore {
 namespace lite {
-
 OpParameter *PopulatePadParameter(const void *prim) {
-  PadParameter *pad_param = reinterpret_cast<PadParameter *>(malloc(sizeof(PadParameter)));
+  auto *pad_param = reinterpret_cast<PadParameter *>(malloc(sizeof(PadParameter)));
   if (pad_param == nullptr) {
     MS_LOG(ERROR) << "malloc PadParameter failed.";
     return nullptr;
   }
   memset(pad_param, 0, sizeof(PadParameter));
   auto primitive = static_cast<const schema::Primitive *>(prim);
+  MS_ASSERT(primitive != nullptr);
   auto value = primitive->value_as_PadFusion();
+  if (value == nullptr) {
+    MS_LOG(ERROR) << "value is nullptr";
+    return nullptr;
+  }
   pad_param->op_parameter_.type_ = primitive->value_type();
   pad_param->pad_mode_ = value->padding_mode();
   pad_param->constant_value_ = value->constant_value();

mindspore/lite/src/ops/populate/partial_populate.cc

@@ -21,14 +21,19 @@ namespace mindspore {
 namespace lite {
 
 OpParameter *PopulatePartialParameter(const void *prim) {
-  PartialParameter *partial_parameter = reinterpret_cast<PartialParameter *>(malloc(sizeof(PartialParameter)));
+  auto *partial_parameter = reinterpret_cast<PartialParameter *>(malloc(sizeof(PartialParameter)));
   if (partial_parameter == nullptr) {
     MS_LOG(ERROR) << "malloc partial parameter failed.";
     return nullptr;
   }
   memset(partial_parameter, 0, sizeof(PartialParameter));
   auto primitive = static_cast<const schema::Primitive *>(prim);
+  MS_ASSERT(primitive != nullptr);
   auto value = primitive->value_as_PartialFusion();
+  if (value == nullptr) {
+    MS_LOG(ERROR) << "value is nullptr";
+    return nullptr;
+  }
   partial_parameter->op_parameter_.type_ = primitive->value_type();
   partial_parameter->sub_graph_index_ = value->sub_graph_index();
 

mindspore/lite/src/ops/populate/pooling_populate.cc

@@ -22,28 +22,44 @@ namespace mindspore {
 namespace lite {
 namespace {
 OpParameter *PopulateAvgPoolParameter(const void *primitive) {
-  PoolingParameter *pooling_param = reinterpret_cast<PoolingParameter *>(malloc(sizeof(PoolingParameter)));
+  auto *pooling_param = reinterpret_cast<PoolingParameter *>(malloc(sizeof(PoolingParameter)));
   if (pooling_param == nullptr) {
     MS_LOG(ERROR) << "malloc PoolingParameter failed.";
     return nullptr;
   }
   memset(pooling_param, 0, sizeof(PoolingParameter));
   auto pooling_prim = static_cast<const schema::Primitive *>(primitive);
+  MS_ASSERT(pooling_prim != nullptr);
   pooling_param->op_parameter_.type_ = pooling_prim->value_type();
   auto pooling_primitive = pooling_prim->value_as_AvgPoolFusion();
+  if (pooling_primitive == nullptr) {
+    MS_LOG(ERROR) << "pooling_primitive is nullptr";
+    return nullptr;
+  }
   pooling_param->pool_mode_ = PoolMode_AvgPool;
   pooling_param->global_ = pooling_primitive->global();
-  pooling_param->stride_w_ = static_cast<int>(*(pooling_primitive->strides()->begin() + 1));
-  pooling_param->stride_h_ = static_cast<int>(*(pooling_primitive->strides()->begin()));
-  if (pooling_primitive->pad() != nullptr) {
-    pooling_param->pad_u_ = static_cast<int>(*(pooling_primitive->pad()->begin()));
-    pooling_param->pad_d_ = static_cast<int>(*(pooling_primitive->pad()->begin() + 1));
-    pooling_param->pad_l_ = static_cast<int>(*(pooling_primitive->pad()->begin() + 2));
-    pooling_param->pad_r_ = static_cast<int>(*(pooling_primitive->pad()->begin() + 3));
+  auto strides = pooling_primitive->strides();
+  if (strides == nullptr) {
+    MS_LOG(ERROR) << "strides is nullptr";
+    return nullptr;
+  }
+  pooling_param->stride_w_ = static_cast<int>(*(strides->begin() + 1));
+  pooling_param->stride_h_ = static_cast<int>(*(strides->begin()));
+  auto pad = pooling_primitive->pad();
+  if (pad != nullptr) {
+    pooling_param->pad_u_ = static_cast<int>(*(pad->begin()));
+    pooling_param->pad_d_ = static_cast<int>(*(pad->begin() + 1));
+    pooling_param->pad_l_ = static_cast<int>(*(pad->begin() + 2));
+    pooling_param->pad_r_ = static_cast<int>(*(pad->begin() + 3));
   }
   if (!pooling_param->global_) {
-    pooling_param->window_w_ = static_cast<int>(*(pooling_primitive->kernel_size()->begin() + 1));
-    pooling_param->window_h_ = static_cast<int>(*(pooling_primitive->kernel_size()->begin()));
+    auto kernel_size = pooling_primitive->kernel_size();
+    if (kernel_size == nullptr) {
+      MS_LOG(ERROR) << "kernel_size is nullptr";
+      return nullptr;
+    }
+    pooling_param->window_w_ = static_cast<int>(*(kernel_size->begin() + 1));
+    pooling_param->window_h_ = static_cast<int>(*(kernel_size->begin()));
   }
 
   auto round_mode = pooling_primitive->round_mode();
@@ -82,27 +98,39 @@ OpParameter *PopulateAvgPoolParameter(const void *primitive) {
 }
 
 OpParameter *PopulateMaxPoolParameter(const void *primitive) {
-  PoolingParameter *pooling_param = reinterpret_cast<PoolingParameter *>(malloc(sizeof(PoolingParameter)));
+  auto *pooling_param = reinterpret_cast<PoolingParameter *>(malloc(sizeof(PoolingParameter)));
   if (pooling_param == nullptr) {
     MS_LOG(ERROR) << "malloc PoolingParameter failed.";
     return nullptr;
   }
   memset(pooling_param, 0, sizeof(PoolingParameter));
   auto pooling_prim = static_cast<const schema::Primitive *>(primitive);
+  MS_ASSERT(pooling_prim != nullptr);
   pooling_param->op_parameter_.type_ = pooling_prim->value_type();
   auto max_pool_prim = pooling_prim->value_as_MaxPoolFusion();
+  if (max_pool_prim == nullptr) {
+    MS_LOG(ERROR) << "max_pool_prim is nullptr";
+    return nullptr;
+  }
   pooling_param->pool_mode_ = PoolMode_MaxPool;
   pooling_param->global_ = max_pool_prim->global();
   if (!pooling_param->global_) {
-    pooling_param->window_w_ = static_cast<int>(*(max_pool_prim->kernel_size()->begin() + 1));
-    pooling_param->window_h_ = static_cast<int>(*(max_pool_prim->kernel_size()->begin()));
-    pooling_param->stride_w_ = static_cast<int>(*(max_pool_prim->strides()->begin() + 1));
-    pooling_param->stride_h_ = static_cast<int>(*(max_pool_prim->strides()->begin()));
-    if (max_pool_prim->pad() != nullptr) {
-      pooling_param->pad_u_ = static_cast<int>(*(max_pool_prim->pad()->begin()));
-      pooling_param->pad_d_ = static_cast<int>(*(max_pool_prim->pad()->begin() + 1));
-      pooling_param->pad_l_ = static_cast<int>(*(max_pool_prim->pad()->begin() + 2));
-      pooling_param->pad_r_ = static_cast<int>(*(max_pool_prim->pad()->begin() + 3));
+    auto kernel_size = max_pool_prim->kernel_size();
+    auto strides = max_pool_prim->strides();
+    if (kernel_size == nullptr || strides == nullptr) {
+      MS_LOG(ERROR) << "kernel_size or strides is nullptr";
+      return nullptr;
+    }
+    pooling_param->window_w_ = static_cast<int>(*(kernel_size->begin() + 1));
+    pooling_param->window_h_ = static_cast<int>(*(kernel_size->begin()));
+    pooling_param->stride_w_ = static_cast<int>(*(strides->begin() + 1));
+    pooling_param->stride_h_ = static_cast<int>(*(strides->begin()));
+    auto pad = max_pool_prim->pad();
+    if (pad != nullptr) {
+      pooling_param->pad_u_ = static_cast<int>(*(pad->begin()));
+      pooling_param->pad_d_ = static_cast<int>(*(pad->begin() + 1));
+      pooling_param->pad_l_ = static_cast<int>(*(pad->begin() + 2));
+      pooling_param->pad_r_ = static_cast<int>(*(pad->begin() + 3));
     }
   }
 

mindspore/lite/src/ops/populate/power_populate.cc

@@ -21,15 +21,20 @@ namespace mindspore {
 namespace lite {
 namespace {
 OpParameter *PopulatePowerParameter(const void *prim) {
-  PowerParameter *power_param = reinterpret_cast<PowerParameter *>(malloc(sizeof(PowerParameter)));
+  auto *power_param = reinterpret_cast<PowerParameter *>(malloc(sizeof(PowerParameter)));
   if (power_param == nullptr) {
     MS_LOG(ERROR) << "malloc PowerParameter failed.";
     return nullptr;
   }
   memset(power_param, 0, sizeof(PowerParameter));
   auto primitive = static_cast<const schema::Primitive *>(prim);
+  MS_ASSERT(primitive != nullptr);
   power_param->op_parameter_.type_ = primitive->value_type();
   auto power_prim = primitive->value_as_PowFusion();
+  if (power_prim == nullptr) {
+    MS_LOG(ERROR) << "power_prim is nullptr";
+    return nullptr;
+  }
   power_param->scale_ = power_prim->scale();
   power_param->shift_ = power_prim->shift();
   return reinterpret_cast<OpParameter *>(power_param);

mindspore/lite/src/ops/populate/prior_box_populate.cc

@@ -19,9 +19,8 @@ using mindspore::schema::PrimitiveType_PriorBox;
 
 namespace mindspore {
 namespace lite {
-
 OpParameter *PopulatePriorBoxParameter(const void *prim) {
-  PriorBoxParameter *prior_box_param = reinterpret_cast<PriorBoxParameter *>(malloc(sizeof(PriorBoxParameter)));
+  auto *prior_box_param = reinterpret_cast<PriorBoxParameter *>(malloc(sizeof(PriorBoxParameter)));
   if (prior_box_param == nullptr) {
     MS_LOG(ERROR) << "malloc PriorBoxParameter failed.";
     return nullptr;
@@ -29,38 +28,64 @@ OpParameter *PopulatePriorBoxParameter(const void *prim) {
   memset(prior_box_param, 0, sizeof(PriorBoxParameter));
 
   auto primitive = static_cast<const schema::Primitive *>(prim);
+  MS_ASSERT(primitive != nullptr);
   auto value = primitive->value_as_PriorBox();
+  if (value == nullptr) {
+    MS_LOG(ERROR) << "value is nullptr";
+    return nullptr;
+  }
   prior_box_param->op_parameter_.type_ = primitive->value_type();
-  if (value->min_sizes()->size() > MAX_SHAPE_SIZE) {
-    MS_LOG(ERROR) << "PriorBox min_sizes size exceeds max num " << MAX_SHAPE_SIZE << ", got " << value->min_sizes();
+  auto min_sizes = value->min_sizes();
+  if (min_sizes == nullptr) {
+    MS_LOG(ERROR) << "min_sizes is nullptr";
+    return nullptr;
+  }
+  if (min_sizes->size() > MAX_SHAPE_SIZE) {
+    MS_LOG(ERROR) << "PriorBox min_sizes size exceeds max num " << MAX_SHAPE_SIZE << ", got " << min_sizes->size();
     free(prior_box_param);
     return nullptr;
   }
-  prior_box_param->min_sizes_size = value->min_sizes()->size();
-  if (value->max_sizes()->size() > MAX_SHAPE_SIZE) {
-    MS_LOG(ERROR) << "PriorBox max_sizes size exceeds max num " << MAX_SHAPE_SIZE << ", got " << value->max_sizes();
+  prior_box_param->min_sizes_size = min_sizes->size();
+  memcpy(prior_box_param->min_sizes, min_sizes->data(), min_sizes->size() * sizeof(int32_t));
+
+  auto max_sizes = value->max_sizes();
+  if (max_sizes == nullptr) {
+    MS_LOG(ERROR) << "max_sizes is nullptr";
+    return nullptr;
+  }
+  if (max_sizes->size() > MAX_SHAPE_SIZE) {
+    MS_LOG(ERROR) << "PriorBox max_sizes size exceeds max num " << MAX_SHAPE_SIZE << ", got " << max_sizes->size();
     free(prior_box_param);
     return nullptr;
   }
-  prior_box_param->max_sizes_size = value->max_sizes()->size();
-  memcpy(prior_box_param->max_sizes, value->max_sizes()->data(), value->max_sizes()->size() * sizeof(int32_t));
-  memcpy(prior_box_param->min_sizes, value->min_sizes()->data(), value->min_sizes()->size() * sizeof(int32_t));
+  prior_box_param->max_sizes_size = max_sizes->size();
+  memcpy(prior_box_param->max_sizes, max_sizes->data(), max_sizes->size() * sizeof(int32_t));
 
-  if (value->aspect_ratios()->size() > MAX_SHAPE_SIZE) {
+  auto aspect_ratios = value->aspect_ratios();
+  if (aspect_ratios == nullptr) {
+    MS_LOG(ERROR) << "aspect_ratios is nullptr";
+    return nullptr;
+  }
+  if (aspect_ratios->size() > MAX_SHAPE_SIZE) {
     MS_LOG(ERROR) << "PriorBox aspect_ratios size exceeds max num " << MAX_SHAPE_SIZE << ", got "
-                  << value->aspect_ratios();
+                  << aspect_ratios->size();
     free(prior_box_param);
     return nullptr;
   }
-  prior_box_param->aspect_ratios_size = value->aspect_ratios()->size();
-  memcpy(prior_box_param->aspect_ratios, value->aspect_ratios()->data(),
-         value->aspect_ratios()->size() * sizeof(float));
-  if (value->variances()->size() != COMM_SHAPE_SIZE) {
-    MS_LOG(ERROR) << "PriorBox variances size should be " << COMM_SHAPE_SIZE << ", got " << value->variances()->size();
+  prior_box_param->aspect_ratios_size = aspect_ratios->size();
+  memcpy(prior_box_param->aspect_ratios, aspect_ratios->data(), aspect_ratios->size() * sizeof(float));
+
+  auto variances = value->variances();
+  if (variances == nullptr) {
+    MS_LOG(ERROR) << "variances is nullptr";
+    return nullptr;
+  }
+  if (variances->size() != COMM_SHAPE_SIZE) {
+    MS_LOG(ERROR) << "PriorBox variances size should be " << COMM_SHAPE_SIZE << ", got " << variances->size();
     free(prior_box_param);
     return nullptr;
   }
-  memcpy(prior_box_param->variances, value->variances()->data(), COMM_SHAPE_SIZE * sizeof(float));
+  memcpy(prior_box_param->variances, variances->data(), COMM_SHAPE_SIZE * sizeof(float));
   prior_box_param->flip = value->flip();
   prior_box_param->clip = value->clip();
   prior_box_param->offset = value->offset();

mindspore/lite/src/ops/populate/quant_dtype_cast_populate.cc

@@ -19,17 +19,20 @@ using mindspore::schema::PrimitiveType_QuantDTypeCast;
 
 namespace mindspore {
 namespace lite {
-
 OpParameter *PopulateQuantDTypeCastParameter(const void *prim) {
-  QuantDTypeCastParameter *parameter =
-    reinterpret_cast<QuantDTypeCastParameter *>(malloc(sizeof(QuantDTypeCastParameter)));
+  auto *parameter = reinterpret_cast<QuantDTypeCastParameter *>(malloc(sizeof(QuantDTypeCastParameter)));
   if (parameter == nullptr) {
     MS_LOG(ERROR) << "malloc QuantDTypeCastParameter failed.";
     return nullptr;
   }
   memset(parameter, 0, sizeof(QuantDTypeCastParameter));
   auto primitive = static_cast<const schema::Primitive *>(prim);
+  MS_ASSERT(primitive != nullptr);
   auto value = primitive->value_as_QuantDTypeCast();
+  if (value == nullptr) {
+    MS_LOG(ERROR) << "value is nullptr";
+    return nullptr;
+  }
   parameter->op_parameter_.type_ = primitive->value_type();
   parameter->srcT = value->src_t();
   parameter->dstT = value->dst_t();

mindspore/lite/src/ops/populate/random_standard_normal_populate.cc

@@ -22,15 +22,20 @@ namespace mindspore {
 namespace lite {
 namespace {
 OpParameter *PopulateRandomStandardNormalParameter(const void *prim) {
-  RandomParam *random_parameter = reinterpret_cast<RandomParam *>(malloc(sizeof(RandomParam)));
+  auto *random_parameter = reinterpret_cast<RandomParam *>(malloc(sizeof(RandomParam)));
   if (random_parameter == nullptr) {
     MS_LOG(ERROR) << "malloc RandomStandardNormal parameter failed.";
     return nullptr;
   }
   memset(random_parameter, 0, sizeof(RandomParam));
   auto *primitive = static_cast<const schema::Primitive *>(prim);
+  MS_ASSERT(primitive != nullptr);
   random_parameter->op_parameter_.type_ = primitive->value_type();
   auto param = primitive->value_as_RandomStandardNormal();
+  if (param == nullptr) {
+    MS_LOG(ERROR) << "param is nullptr";
+    return nullptr;
+  }
   random_parameter->seed_ = param->seed();
   random_parameter->seed2_ = param->seed2();
   return reinterpret_cast<OpParameter *>(random_parameter);

mindspore/lite/src/ops/populate/range_populate.cc

@@ -21,15 +21,20 @@ namespace mindspore {
 namespace lite {
 namespace {
 OpParameter *PopulateRangeParameter(const void *prim) {
-  RangeParameter *range_param = reinterpret_cast<RangeParameter *>(malloc(sizeof(RangeParameter)));
+  auto *range_param = reinterpret_cast<RangeParameter *>(malloc(sizeof(RangeParameter)));
   if (range_param == nullptr) {
     MS_LOG(ERROR) << "malloc RangeParameter failed.";
     return nullptr;
   }
   memset(range_param, 0, sizeof(RangeParameter));
   auto primitive = static_cast<const schema::Primitive *>(prim);
+  MS_ASSERT(primitive != nullptr);
   range_param->op_parameter_.type_ = primitive->value_type();
   auto range_prim = primitive->value_as_Range();
+  if (range_prim == nullptr) {
+    MS_LOG(ERROR) << "range_prim is nullptr";
+    return nullptr;
+  }
   range_param->start_ = range_prim->start();
   range_param->limit_ = range_prim->limit();
   range_param->delta_ = range_prim->delta();

mindspore/lite/src/ops/populate/rank_populate.cc

@@ -20,13 +20,14 @@ namespace mindspore {
 namespace lite {
 namespace {
 OpParameter *PopulateRankParameter(const void *prim) {
-  OpParameter *rank_param = reinterpret_cast<OpParameter *>(malloc(sizeof(OpParameter)));
+  auto *rank_param = reinterpret_cast<OpParameter *>(malloc(sizeof(OpParameter)));
   if (rank_param == nullptr) {
     MS_LOG(ERROR) << "malloc RankParameter failed.";
     return nullptr;
   }
   memset(rank_param, 0, sizeof(OpParameter));
   auto primitive = static_cast<const schema::Primitive *>(prim);
+  MS_ASSERT(primitive != nullptr);
   rank_param->type_ = primitive->value_type();
   return reinterpret_cast<OpParameter *>(rank_param);
 }

mindspore/lite/src/ops/populate/reduce_populate.cc

@@ -19,16 +19,20 @@
 using mindspore::schema::PrimitiveType_ReduceFusion;
 namespace mindspore {
 namespace lite {
-
 OpParameter *PopulateReduceParameter(const void *prim) {
-  ReduceParameter *reduce_param = reinterpret_cast<ReduceParameter *>(malloc(sizeof(ReduceParameter)));
+  auto *reduce_param = reinterpret_cast<ReduceParameter *>(malloc(sizeof(ReduceParameter)));
   if (reduce_param == nullptr) {
     MS_LOG(ERROR) << "malloc ReduceParameter failed.";
     return nullptr;
   }
   memset(reduce_param, 0, sizeof(ReduceParameter));
   auto primitive = static_cast<const schema::Primitive *>(prim);
+  MS_ASSERT(primitive != nullptr);
   auto value = primitive->value_as_ReduceFusion();
+  if (value == nullptr) {
+    MS_LOG(ERROR) << "value is nullptr";
+    return nullptr;
+  }
   reduce_param->op_parameter_.type_ = primitive->value_type();
   reduce_param->keep_dims_ = value->keep_dims();
   reduce_param->reduce_to_end_ = value->reduce_to_end();

mindspore/lite/src/ops/populate/reshape_populate.cc

@@ -21,13 +21,14 @@ namespace mindspore {
 namespace lite {
 namespace {
 OpParameter *PopulateReshapeParameter(const void *prim) {
-  ReshapeParameter *reshape_param = reinterpret_cast<ReshapeParameter *>(malloc(sizeof(ReshapeParameter)));
+  auto *reshape_param = reinterpret_cast<ReshapeParameter *>(malloc(sizeof(ReshapeParameter)));
   if (reshape_param == nullptr) {
     MS_LOG(ERROR) << "malloc ReshapeParameter failed.";
     return nullptr;
   }
   memset(reshape_param, 0, sizeof(ReshapeParameter));
   auto *primitive = static_cast<const schema::Primitive *>(prim);
+  MS_ASSERT(primitive != nullptr);
   reshape_param->op_parameter_.type_ = primitive->value_type();
   return reinterpret_cast<OpParameter *>(reshape_param);
 }

mindspore/lite/src/ops/populate/resize_populate.cc

@@ -19,16 +19,20 @@ using mindspore::schema::PrimitiveType_Resize;
 
 namespace mindspore {
 namespace lite {
-
 OpParameter *PopulateResizeParameter(const void *prim) {
-  ResizeParameter *resize_param = reinterpret_cast<ResizeParameter *>(malloc(sizeof(ResizeParameter)));
+  auto *resize_param = reinterpret_cast<ResizeParameter *>(malloc(sizeof(ResizeParameter)));
   if (resize_param == nullptr) {
     MS_LOG(ERROR) << "malloc ResizeParameter failed.";
     return nullptr;
   }
   memset(resize_param, 0, sizeof(ResizeParameter));
   auto primitive = static_cast<const schema::Primitive *>(prim);
+  MS_ASSERT(primitive != nullptr);
   auto value = primitive->value_as_Resize();
+  if (value == nullptr) {
+    MS_LOG(ERROR) << "value is nullptr";
+    return nullptr;
+  }
   resize_param->op_parameter_.type_ = primitive->value_type();
 
   resize_param->method_ = static_cast<int>(value->method());

mindspore/lite/src/ops/populate/reverse_populate.cc

@@ -19,19 +19,27 @@ using mindspore::schema::PrimitiveType_ReverseV2;
 
 namespace mindspore {
 namespace lite {
-
 OpParameter *PopulateReverseParameter(const void *prim) {
-  ReverseParameter *reverse_param = reinterpret_cast<ReverseParameter *>(malloc(sizeof(ReverseParameter)));
+  auto *reverse_param = reinterpret_cast<ReverseParameter *>(malloc(sizeof(ReverseParameter)));
   if (reverse_param == nullptr) {
     MS_LOG(ERROR) << "malloc ReverseParameter failed.";
     return nullptr;
   }
   memset(reverse_param, 0, sizeof(ReverseParameter));
   auto primitive = static_cast<const schema::Primitive *>(prim);
+  MS_ASSERT(primitive != nullptr);
   auto value = primitive->value_as_ReverseV2();
+  if (value == nullptr) {
+    MS_LOG(ERROR) << "value is nullptr";
+    return nullptr;
+  }
   reverse_param->op_parameter_.type_ = primitive->value_type();
 
   auto flatAxis = value->axis();
+  if (flatAxis == nullptr) {
+    MS_LOG(ERROR) << "flatAxis is nullptr";
+    return nullptr;
+  }
   reverse_param->num_axis_ = flatAxis->size();
   int i = 0;
   for (auto iter = flatAxis->begin(); iter != flatAxis->end(); iter++) {

mindspore/lite/src/ops/populate/reverse_sequence_populate.cc

@@ -21,15 +21,19 @@ namespace mindspore {
 namespace lite {
 namespace {
 OpParameter *PopulateReverseSequenceParameter(const void *prim) {
-  ReverseSequenceParameter *reverse_sequence_param =
-    reinterpret_cast<ReverseSequenceParameter *>(malloc(sizeof(ReverseSequenceParameter)));
+  auto *reverse_sequence_param = reinterpret_cast<ReverseSequenceParameter *>(malloc(sizeof(ReverseSequenceParameter)));
   if (reverse_sequence_param == nullptr) {
     MS_LOG(ERROR) << "malloc ReverseSequenceParameter failed.";
     return nullptr;
   }
   memset(reverse_sequence_param, 0, sizeof(ReverseSequenceParameter));
   auto primitive = static_cast<const schema::Primitive *>(prim);
+  MS_ASSERT(primitive != nullptr);
   auto param = primitive->value_as_ReverseSequence();
+  if (param == nullptr) {
+    MS_LOG(ERROR) << "param is nullptr";
+    return nullptr;
+  }
   reverse_sequence_param->op_parameter_.type_ = primitive->value_type();
   reverse_sequence_param->seq_axis_ = static_cast<int>(param->seq_dim());
   reverse_sequence_param->batch_axis_ = static_cast<int>(param->batch_dim());

mindspore/lite/src/ops/populate/roi_pooling_populate.cc

@@ -21,7 +21,7 @@ namespace mindspore {
 namespace lite {
 namespace {
 OpParameter *PopulateROIPoolingParameter(const void *prim) {
-  ROIPoolingParameter *roi_param = reinterpret_cast<ROIPoolingParameter *>(malloc(sizeof(ROIPoolingParameter)));
+  auto *roi_param = reinterpret_cast<ROIPoolingParameter *>(malloc(sizeof(ROIPoolingParameter)));
   if (roi_param == nullptr) {
     MS_LOG(ERROR) << "malloc ROIPoolingParameter failed.";
     return nullptr;
@@ -29,8 +29,13 @@ OpParameter *PopulateROIPoolingParameter(const void *prim) {
 
   memset(roi_param, 0, sizeof(ROIPoolingParameter));
   auto primitive = static_cast<const schema::Primitive *>(prim);
+  MS_ASSERT(primitive != nullptr);
   roi_param->op_parameter_.type_ = primitive->value_type();
   auto roi_prim = primitive->value_as_ROIPooling();
+  if (roi_prim == nullptr) {
+    MS_LOG(ERROR) << "roi_prim is nullptr";
+    return nullptr;
+  }
   roi_param->pooledH_ = roi_prim->pooled_h();
   roi_param->pooledW_ = roi_prim->pooled_w();
   roi_param->scale_ = roi_prim->scale();

mindspore/lite/src/ops/populate/scale_populate.cc

@@ -21,14 +21,19 @@ namespace mindspore {
 namespace lite {
 namespace {
 OpParameter *PopulateScaleParameter(const void *prim) {
-  ScaleParameter *scale_param = reinterpret_cast<ScaleParameter *>(malloc(sizeof(ScaleParameter)));
+  auto *scale_param = reinterpret_cast<ScaleParameter *>(malloc(sizeof(ScaleParameter)));
   if (scale_param == nullptr) {
     MS_LOG(ERROR) << "malloc ScaleParameter failed.";
     return nullptr;
   }
   memset(scale_param, 0, sizeof(ScaleParameter));
   auto primitive = static_cast<const schema::Primitive *>(prim);
+  MS_ASSERT(primitive != nullptr);
   auto value = primitive->value_as_ScaleFusion();
+  if (value == nullptr) {
+    MS_LOG(ERROR) << "value is nullptr";
+    return nullptr;
+  }
   scale_param->op_parameter_.type_ = primitive->value_type();
   scale_param->axis_ = value->axis();
   scale_param->activation_type_ = value->activation_type();

mindspore/lite/src/ops/populate/scatter_nd_populate.cc

@@ -20,13 +20,14 @@ namespace mindspore {
 namespace lite {
 namespace {
 OpParameter *PopulateScatterNDParameter(const void *prim) {
-  OpParameter *scatter_nd_param = reinterpret_cast<OpParameter *>(malloc(sizeof(OpParameter)));
+  auto *scatter_nd_param = reinterpret_cast<OpParameter *>(malloc(sizeof(OpParameter)));
   if (scatter_nd_param == nullptr) {
     MS_LOG(ERROR) << "malloc ScatterNDParameter failed.";
     return nullptr;
   }
   memset(scatter_nd_param, 0, sizeof(OpParameter));
   auto primitive = static_cast<const schema::Primitive *>(prim);
+  MS_ASSERT(primitive != nullptr);
   scatter_nd_param->type_ = primitive->value_type();
   return reinterpret_cast<OpParameter *>(scatter_nd_param);
 }

mindspore/lite/src/ops/populate/shape_populate.cc

@@ -22,13 +22,14 @@ namespace mindspore {
 namespace lite {
 namespace {
 OpParameter *PopulateShapeParameter(const void *prim) {
-  OpParameter *shape_param = reinterpret_cast<OpParameter *>(malloc(sizeof(OpParameter)));
+  auto *shape_param = reinterpret_cast<OpParameter *>(malloc(sizeof(OpParameter)));
   if (shape_param == nullptr) {
     MS_LOG(ERROR) << "malloc ShapeParameter failed.";
     return nullptr;
   }
   memset(shape_param, 0, sizeof(OpParameter));
   auto primitive = static_cast<const schema::Primitive *>(prim);
+  MS_ASSERT(primitive != nullptr);
   shape_param->type_ = primitive->value_type();
   return reinterpret_cast<OpParameter *>(shape_param);
 }