From ed7569c03f08dd0c7c195d08efa9a707eb8a3795 Mon Sep 17 00:00:00 2001 From: liuyu Date: Wed, 28 Apr 2021 10:41:05 +0800 Subject: [PATCH] check nullptr --- .../ops/compat/v0/broadcast_to_compat_v0.cc | 12 +++- .../lite/src/ops/compat/v0/cast_compat_v0.cc | 8 ++- .../ops/compat/v0/expand_dims_compat_v0.cc | 8 ++- .../lite/src/ops/compat/v0/fill_compat_v0.cc | 12 +++- .../src/ops/compat/v0/gather_compat_v0.cc | 8 ++- .../lite/src/ops/compat/v0/pad_compat_v0.cc | 12 +++- .../src/ops/compat/v0/permute_compat_v0.cc | 13 +++- .../lite/src/ops/compat/v0/power_compat_v0.cc | 8 ++- .../src/ops/compat/v0/reduce_compat_v0.cc | 12 +++- .../src/ops/compat/v0/reshape_compat_v0.cc | 12 +++- .../lite/src/ops/compat/v0/slice_compat_v0.cc | 18 ++++- .../ops/compat/v0/strided_slice_compat_v0.cc | 25 ++++++- .../lite/src/ops/compat/v0/tile_compat_v0.cc | 12 +++- .../lite/src/ops/compat/v0/topk_compat_v0.cc | 8 ++- .../src/ops/compat/v0/transpose_compat_v0.cc | 12 +++- .../ops/populate/activation_grad_populate.cc | 8 ++- .../src/ops/populate/activation_populate.cc | 7 +- .../lite/src/ops/populate/adam_populate.cc | 3 +- .../lite/src/ops/populate/add_populate.cc | 4 ++ .../lite/src/ops/populate/adder_populate.cc | 33 ++++++--- .../lite/src/ops/populate/addn_populate.cc | 3 +- .../lite/src/ops/populate/argmax_populate.cc | 6 +- .../lite/src/ops/populate/argmin_populate.cc | 4 ++ .../src/ops/populate/arithmetic_populate.cc | 5 +- .../ops/populate/arithmetic_self_populate.cc | 6 +- .../lite/src/ops/populate/assert_populate.cc | 3 +- .../src/ops/populate/assign_add_populate.cc | 3 +- .../lite/src/ops/populate/assign_populate.cc | 3 +- .../populate/audio_spectrogram_populate.cc | 7 +- .../src/ops/populate/batch_norm_populate.cc | 9 ++- .../ops/populate/batch_to_space_populate.cc | 30 ++++++-- .../src/ops/populate/bias_add_populate.cc | 5 +- .../src/ops/populate/bias_grad_populate.cc | 3 +- .../binary_cross_entropy_grad_populate.cc | 7 +- .../populate/binary_cross_entropy_populate.cc | 5 ++ .../src/ops/populate/broadcast_to_populate.cc | 12 +++- .../lite/src/ops/populate/cast_populate.cc | 3 +- .../lite/src/ops/populate/clip_populate.cc | 3 +- .../lite/src/ops/populate/common_populate.cc | 1 + .../lite/src/ops/populate/concat_populate.cc | 12 +++- .../populate/constant_of_shape_populate.cc | 19 ++++-- .../lite/src/ops/populate/conv2d_populate.cc | 37 ++++++---- .../ops/populate/crop_and_resize_populate.cc | 8 ++- .../lite/src/ops/populate/crop_populate.cc | 11 ++- .../custom_extract_features_populate.cc | 3 +- .../ops/populate/custom_normalize_populate.cc | 4 +- .../ops/populate/custom_predict_populate.cc | 6 +- .../src/ops/populate/deconv2d_populate.cc | 43 ++++++++---- .../populate/dedepthwise_conv2d_populate.cc | 61 ----------------- .../lite/src/ops/populate/default_populate.cc | 3 +- .../ops/populate/depth_to_space_populate.cc | 8 ++- .../ops/populate/depthwise_conv2d_populate.cc | 3 +- .../detection_post_process_populate.cc | 20 ++++-- .../lite/src/ops/populate/div_populate.cc | 3 +- .../lite/src/ops/populate/eltwise_populate.cc | 8 ++- .../lite/src/ops/populate/elu_populate.cc | 7 +- .../ops/populate/embedding_lookup_populate.cc | 8 ++- .../lite/src/ops/populate/exp_populate.cc | 7 +- .../src/ops/populate/expand_dims_populate.cc | 3 +- .../lite/src/ops/populate/fill_populate.cc | 3 +- .../lite/src/ops/populate/flatten_populate.cc | 3 +- .../ops/populate/full_connection_populate.cc | 7 +- .../ops/populate/fused_batchnorm_populate.cc | 8 ++- .../src/ops/populate/gather_nd_populate.cc | 3 +- .../lite/src/ops/populate/gather_populate.cc | 3 +- .../lite/src/ops/populate/gru_populate.cc | 5 +- .../ops/populate/hashtable_lookup_populate.cc | 4 +- .../ops/populate/instance_norm_populate.cc | 8 ++- .../lite/src/ops/populate/l2_norm_populate.cc | 12 +++- .../ops/populate/layer_norm_grad_populate.cc | 5 ++ .../src/ops/populate/layer_norm_populate.cc | 5 ++ .../local_response_normalization_populate.cc | 9 ++- .../src/ops/populate/log_softmax_populate.cc | 7 +- .../ops/populate/lsh_projection_populate.cc | 9 ++- .../lite/src/ops/populate/lstm_populate.cc | 3 +- .../lite/src/ops/populate/matmul_populate.cc | 8 ++- .../lite/src/ops/populate/merge_populate.cc | 4 +- .../lite/src/ops/populate/mfcc_populate.cc | 7 +- .../lite/src/ops/populate/mul_populate.cc | 1 + .../populate/non_max_suppression_populate.cc | 8 ++- .../lite/src/ops/populate/one_hot_populate.cc | 8 ++- .../src/ops/populate/oneslike_populate.cc | 3 +- .../lite/src/ops/populate/p_relu_populate.cc | 6 +- .../lite/src/ops/populate/pad_populate.cc | 8 ++- .../lite/src/ops/populate/partial_populate.cc | 7 +- .../lite/src/ops/populate/pooling_populate.cc | 68 +++++++++++++------ .../lite/src/ops/populate/power_populate.cc | 7 +- .../src/ops/populate/prior_box_populate.cc | 61 ++++++++++++----- .../ops/populate/quant_dtype_cast_populate.cc | 9 ++- .../random_standard_normal_populate.cc | 7 +- .../lite/src/ops/populate/range_populate.cc | 7 +- .../lite/src/ops/populate/rank_populate.cc | 3 +- .../lite/src/ops/populate/reduce_populate.cc | 8 ++- .../lite/src/ops/populate/reshape_populate.cc | 3 +- .../lite/src/ops/populate/resize_populate.cc | 8 ++- .../lite/src/ops/populate/reverse_populate.cc | 12 +++- .../ops/populate/reverse_sequence_populate.cc | 8 ++- .../src/ops/populate/roi_pooling_populate.cc | 7 +- .../lite/src/ops/populate/scale_populate.cc | 7 +- .../src/ops/populate/scatter_nd_populate.cc | 3 +- .../lite/src/ops/populate/shape_populate.cc | 3 +- .../src/ops/populate/skip_gram_populate.cc | 8 ++- .../lite/src/ops/populate/slice_populate.cc | 17 +++-- .../lite/src/ops/populate/softmax_populate.cc | 18 +++-- .../populate/space_to_batch_nd_populate.cc | 32 +++++++-- .../ops/populate/space_to_batch_populate.cc | 37 ++++++++-- .../ops/populate/space_to_depth_populate.cc | 8 ++- ...parse_softmax_cross_entropy_with_logits.cc | 3 +- .../ops/populate/sparse_to_dense_populate.cc | 1 + .../lite/src/ops/populate/splice_populate.cc | 20 +++++- .../lite/src/ops/populate/split_populate.cc | 7 +- .../lite/src/ops/populate/squeeze_populate.cc | 12 +++- .../lite/src/ops/populate/stack_populate.cc | 7 +- .../populate/strided_slice_grad_populate.cc | 5 ++ .../ops/populate/strided_slice_populate.cc | 8 ++- .../lite/src/ops/populate/sub_populate.cc | 2 +- .../lite/src/ops/populate/switch_populate.cc | 3 +- .../populate/tensorlistfromtensor_populate.cc | 7 +- .../populate/tensorlistgetitem_populate.cc | 7 +- .../populate/tensorlistreserve_populate.cc | 7 +- .../populate/tensorlistsetlitem_populate.cc | 7 +- .../ops/populate/tensorliststack_populate.cc | 7 +- .../lite/src/ops/populate/tile_populate.cc | 8 ++- .../lite/src/ops/populate/topk_populate.cc | 7 +- .../src/ops/populate/transpose_populate.cc | 3 +- .../src/ops/populate/uniform_real_populate.cc | 5 ++ .../lite/src/ops/populate/unique_populate.cc | 3 +- .../populate/unsorted_segment_sum_populate.cc | 3 +- .../src/ops/populate/unsqueeze_populate.cc | 14 +++- .../lite/src/ops/populate/unstack_populate.cc | 7 +- .../v0/activation_grad_populate_v0.cc | 8 ++- .../ops/populate/v0/activation_populate_v0.cc | 7 +- .../src/ops/populate/v0/add_populate_v0.cc | 7 +- .../src/ops/populate/v0/argmax_populate_v0.cc | 7 +- .../src/ops/populate/v0/argmin_populate_v0.cc | 7 +- .../ops/populate/v0/arithmetic_populate_v0.cc | 5 +- .../v0/arithmetic_self_populate_v0.cc | 6 +- .../ops/populate/v0/batch_norm_populate_v0.cc | 8 ++- .../populate/v0/batch_to_space_populate_v0.cc | 16 ++++- .../binary_cross_entropy_grad_populate_v0.cc | 7 +- .../v0/binary_cross_entropy_populate_v0.cc | 8 ++- .../populate/v0/broadcast_to_populate_v0.cc | 12 +++- .../src/ops/populate/v0/common_populate_v0.cc | 4 +- .../src/ops/populate/v0/concat_populate_v0.cc | 7 +- .../v0/constant_of_shape_populate_v0.cc | 18 +++-- .../src/ops/populate/v0/conv2d_populate_v0.cc | 8 ++- .../src/ops/populate/v0/crop_populate_v0.cc | 12 +++- .../v0/custom_extract_features_populate_v0.cc | 6 +- .../v0/custom_normalize_populate_v0.cc | 6 +- .../populate/v0/custom_predict_populate_v0.cc | 7 +- .../ops/populate/v0/deconv2d_populate_v0.cc | 7 +- .../v0/dedepthwise_conv2d_populate_v0.cc | 10 +-- .../populate/v0/depth_to_space_populate_v0.cc | 9 ++- .../v0/depthwise_conv2d_populate_v0.cc | 9 ++- .../v0/detection_post_process_populate_v0.cc | 7 +- .../src/ops/populate/v0/div_populate_v0.cc | 7 +- .../ops/populate/v0/eltwise_populate_v0.cc | 9 ++- .../src/ops/populate/v0/elu_populate_v0.cc | 7 +- .../v0/embedding_lookup_populate_v0.cc | 7 +- .../src/ops/populate/v0/exp_populate_v0.cc | 7 +- .../v0/full_connection_populate_v0.cc | 9 ++- .../v0/fused_batchnorm_populate_v0.cc | 7 +- .../src/ops/populate/v0/gather_populate_v0.cc | 8 ++- .../populate/v0/instance_norm_populate_v0.cc | 8 ++- .../ops/populate/v0/l2_norm_populate_v0.cc | 12 +++- .../ops/populate/v0/layer_norm_populate_v0.cc | 5 ++ ...ocal_response_normalization_populate_v0.cc | 9 ++- .../populate/v0/lsh_projection_populate_v0.cc | 8 ++- .../src/ops/populate/v0/lstm_populate_v0.cc | 12 ++-- .../src/ops/populate/v0/matmul_populate_v0.cc | 8 ++- .../src/ops/populate/v0/mul_populate_v0.cc | 7 +- .../v0/non_max_suppression_populate_v0.cc | 7 +- .../ops/populate/v0/one_hot_populate_v0.cc | 13 ++-- .../src/ops/populate/v0/p_relu_populate_v0.cc | 8 ++- .../src/ops/populate/v0/pad_populate_v0.cc | 7 +- .../ops/populate/v0/partial_populate_v0.cc | 7 +- .../ops/populate/v0/pooling_populate_v0.cc | 8 ++- .../src/ops/populate/v0/power_populate_v0.cc | 7 +- .../ops/populate/v0/prior_box_populate_v0.cc | 67 +++++++++++------- .../v0/quant_dtype_cast_populate_v0.cc | 8 ++- .../src/ops/populate/v0/range_populate_v0.cc | 8 ++- .../src/ops/populate/v0/reduce_populate_v0.cc | 11 ++- .../src/ops/populate/v0/resize_populate_v0.cc | 7 +- .../ops/populate/v0/reverse_populate_v0.cc | 12 +++- .../v0/reverse_sequence_populate_v0.cc | 8 ++- .../populate/v0/roi_pooling_populate_v0.cc | 8 ++- .../src/ops/populate/v0/scale_populate_v0.cc | 7 +- .../ops/populate/v0/skip_gram_populate_v0.cc | 7 +- .../src/ops/populate/v0/slice_populate_v0.cc | 11 ++- .../ops/populate/v0/softmax_populate_v0.cc | 8 ++- .../v0/space_to_batch_nd_populate_v0.cc | 13 ++++ .../populate/v0/space_to_batch_populate_v0.cc | 20 ++++-- .../populate/v0/space_to_depth_populate_v0.cc | 8 ++- .../src/ops/populate/v0/split_populate_v0.cc | 7 +- .../v0/squared_difference_populate_v0.cc | 1 + .../ops/populate/v0/squeeze_populate_v0.cc | 14 ++-- .../src/ops/populate/v0/stack_populate_v0.cc | 7 +- .../populate/v0/strided_slice_populate_v0.cc | 8 ++- .../src/ops/populate/v0/sub_populate_v0.cc | 7 +- .../v0/tensorlistfromtensor_populate_v0.cc | 7 +- .../v0/tensorlistgetitem_populate_v0.cc | 7 +- .../v0/tensorlistreserve_populate_v0.cc | 7 +- .../v0/tensorlistsetlitem_populate_v0.cc | 7 +- .../v0/tensorliststack_populate_v0.cc | 7 +- .../src/ops/populate/v0/tile_populate_v0.cc | 9 ++- .../src/ops/populate/v0/topk_populate_v0.cc | 7 +- .../ops/populate/v0/transpose_populate_v0.cc | 13 +++- .../ops/populate/v0/unsqueeze_populate_v0.cc | 12 +++- .../ops/populate/v0/unstack_populate_v0.cc | 7 +- .../src/ops/populate/v0/while_populate_v0.cc | 7 +- .../lite/src/ops/populate/where_populate.cc | 3 +- .../lite/src/ops/populate/while_populate.cc | 7 +- mindspore/lite/tools/converter/converter.cc | 5 +- 213 files changed, 1525 insertions(+), 497 deletions(-) delete mode 100644 mindspore/lite/src/ops/populate/dedepthwise_conv2d_populate.cc diff --git a/mindspore/lite/src/ops/compat/v0/broadcast_to_compat_v0.cc b/mindspore/lite/src/ops/compat/v0/broadcast_to_compat_v0.cc index fd944e821c..cb396dc10c 100644 --- a/mindspore/lite/src/ops/compat/v0/broadcast_to_compat_v0.cc +++ b/mindspore/lite/src/ops/compat/v0/broadcast_to_compat_v0.cc @@ -31,7 +31,17 @@ int TransferBroadcastToAttr(Model::Node *node, std::vector *ds } dst_tensors->clear(); auto prim = reinterpret_cast(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 dst_shape = std::vector(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) { diff --git a/mindspore/lite/src/ops/compat/v0/cast_compat_v0.cc b/mindspore/lite/src/ops/compat/v0/cast_compat_v0.cc index 583f7cc93c..4e211821ec 100644 --- a/mindspore/lite/src/ops/compat/v0/cast_compat_v0.cc +++ b/mindspore/lite/src/ops/compat/v0/cast_compat_v0.cc @@ -26,7 +26,13 @@ int TransferCastAttr(Model::Node *node, std::vector *dst_tenso } dst_tensors->clear(); auto prim = reinterpret_cast(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."; diff --git a/mindspore/lite/src/ops/compat/v0/expand_dims_compat_v0.cc b/mindspore/lite/src/ops/compat/v0/expand_dims_compat_v0.cc index 140784ba5a..f2ca4983ce 100644 --- a/mindspore/lite/src/ops/compat/v0/expand_dims_compat_v0.cc +++ b/mindspore/lite/src/ops/compat/v0/expand_dims_compat_v0.cc @@ -29,7 +29,13 @@ int TransferExpandDimsAttr(Model::Node *node, std::vector *dst MS_ASSERT(dst_tensors->size() == 0); auto prim = reinterpret_cast(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."; diff --git a/mindspore/lite/src/ops/compat/v0/fill_compat_v0.cc b/mindspore/lite/src/ops/compat/v0/fill_compat_v0.cc index 5ab1f62148..f46478778d 100644 --- a/mindspore/lite/src/ops/compat/v0/fill_compat_v0.cc +++ b/mindspore/lite/src/ops/compat/v0/fill_compat_v0.cc @@ -31,7 +31,17 @@ int TransferFillToAttr(Model::Node *node, std::vector *dst_ten } dst_tensors->clear(); auto prim = reinterpret_cast(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 dims = std::vector(dims_attr->begin(), dims_attr->end()); auto dims_tensor = AttrToTensor(dims.data(), dims.size(), true, kNumberTypeInt32, tensor_bufs); if (dims_tensor == nullptr) { diff --git a/mindspore/lite/src/ops/compat/v0/gather_compat_v0.cc b/mindspore/lite/src/ops/compat/v0/gather_compat_v0.cc index 179e65a433..b3b064ee06 100644 --- a/mindspore/lite/src/ops/compat/v0/gather_compat_v0.cc +++ b/mindspore/lite/src/ops/compat/v0/gather_compat_v0.cc @@ -27,7 +27,13 @@ int TransferGatherAttr(Model::Node *node, std::vector *dst_ten } dst_tensors->clear(); auto prim = reinterpret_cast(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."; diff --git a/mindspore/lite/src/ops/compat/v0/pad_compat_v0.cc b/mindspore/lite/src/ops/compat/v0/pad_compat_v0.cc index f4fb1c5416..bab8bb545e 100644 --- a/mindspore/lite/src/ops/compat/v0/pad_compat_v0.cc +++ b/mindspore/lite/src/ops/compat/v0/pad_compat_v0.cc @@ -30,7 +30,17 @@ int TransferPadAttr(Model::Node *node, std::vector *dst_tensor return RET_OK; } auto prim = reinterpret_cast(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 paddings = std::vector(paddings_attr->begin(), paddings_attr->end()); auto paddings_tensor = AttrToTensor(paddings.data(), paddings.size(), true, kNumberTypeInt32, tensor_bufs); if (paddings_tensor == nullptr) { diff --git a/mindspore/lite/src/ops/compat/v0/permute_compat_v0.cc b/mindspore/lite/src/ops/compat/v0/permute_compat_v0.cc index ec76fa82d9..9c59a9af23 100644 --- a/mindspore/lite/src/ops/compat/v0/permute_compat_v0.cc +++ b/mindspore/lite/src/ops/compat/v0/permute_compat_v0.cc @@ -31,8 +31,17 @@ int TransferPermuteAttr(Model::Node *node, std::vector *dst_te } dst_tensors->clear(); auto prim = reinterpret_cast(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 dst_shape; for (auto it = order_attr->begin(); it != order_attr->end(); ++it) { dst_shape.push_back(static_cast(*it)); diff --git a/mindspore/lite/src/ops/compat/v0/power_compat_v0.cc b/mindspore/lite/src/ops/compat/v0/power_compat_v0.cc index ea999154d9..b3cca54a35 100644 --- a/mindspore/lite/src/ops/compat/v0/power_compat_v0.cc +++ b/mindspore/lite/src/ops/compat/v0/power_compat_v0.cc @@ -31,7 +31,13 @@ int TransferPowerToAttr(Model::Node *node, std::vector *dst_te } dst_tensors->clear(); auto prim = reinterpret_cast(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."; diff --git a/mindspore/lite/src/ops/compat/v0/reduce_compat_v0.cc b/mindspore/lite/src/ops/compat/v0/reduce_compat_v0.cc index 463f5edd10..43b38ff08c 100644 --- a/mindspore/lite/src/ops/compat/v0/reduce_compat_v0.cc +++ b/mindspore/lite/src/ops/compat/v0/reduce_compat_v0.cc @@ -31,7 +31,17 @@ int TransferReduceToAttr(Model::Node *node, std::vector *dst_t } dst_tensors->clear(); auto prim = reinterpret_cast(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 axes = std::vector(axes_attr->begin(), axes_attr->end()); auto axes_tensor = AttrToTensor(axes.data(), axes.size(), true, kNumberTypeInt32, tensor_bufs); if (axes_tensor == nullptr) { diff --git a/mindspore/lite/src/ops/compat/v0/reshape_compat_v0.cc b/mindspore/lite/src/ops/compat/v0/reshape_compat_v0.cc index ec919c898b..76532180d5 100644 --- a/mindspore/lite/src/ops/compat/v0/reshape_compat_v0.cc +++ b/mindspore/lite/src/ops/compat/v0/reshape_compat_v0.cc @@ -31,7 +31,17 @@ int TransferReshapeAttr(Model::Node *node, std::vector *dst_te } dst_tensors->clear(); auto prim = reinterpret_cast(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 dst_shape = std::vector(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) { diff --git a/mindspore/lite/src/ops/compat/v0/slice_compat_v0.cc b/mindspore/lite/src/ops/compat/v0/slice_compat_v0.cc index 2472c7aa27..a1e69ff6ce 100644 --- a/mindspore/lite/src/ops/compat/v0/slice_compat_v0.cc +++ b/mindspore/lite/src/ops/compat/v0/slice_compat_v0.cc @@ -30,9 +30,19 @@ int TransferSliceAttr(Model::Node *node, std::vector *dst_tens } MS_ASSERT(dst_tensors->size() == 0); auto prim = reinterpret_cast(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 begin_shape = std::vector(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 *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 size_shape = std::vector(size_attr->begin(), size_attr->end()); auto size_tensor = AttrToTensor(size_shape.data(), size_shape.size(), true, kNumberTypeInt32, tensor_bufs); if (size_tensor == nullptr) { diff --git a/mindspore/lite/src/ops/compat/v0/strided_slice_compat_v0.cc b/mindspore/lite/src/ops/compat/v0/strided_slice_compat_v0.cc index 5bbd541d96..1db53a5bd3 100644 --- a/mindspore/lite/src/ops/compat/v0/strided_slice_compat_v0.cc +++ b/mindspore/lite/src/ops/compat/v0/strided_slice_compat_v0.cc @@ -27,22 +27,41 @@ int TransferStridedSliceAttr(Model::Node *node, std::vector *d } dst_tensors->clear(); auto prim = reinterpret_cast(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 dst_begins = std::vector(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 dst_ends = std::vector(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 dst_strides = std::vector(strides_attr->begin(), strides_attr->end()); auto dst_strides_tensor = AttrToTensor(dst_strides.data(), dst_strides.size(), true, kNumberTypeInt32, tensor_bufs); diff --git a/mindspore/lite/src/ops/compat/v0/tile_compat_v0.cc b/mindspore/lite/src/ops/compat/v0/tile_compat_v0.cc index 3960fef8eb..e675f05552 100644 --- a/mindspore/lite/src/ops/compat/v0/tile_compat_v0.cc +++ b/mindspore/lite/src/ops/compat/v0/tile_compat_v0.cc @@ -31,7 +31,17 @@ int TransferTileToAttr(Model::Node *node, std::vector *dst_ten } dst_tensors->clear(); auto prim = reinterpret_cast(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 multiples = std::vector(multiples_attr->begin(), multiples_attr->end()); auto multiples_tensor = AttrToTensor(multiples.data(), multiples.size(), true, kNumberTypeInt32, tensor_bufs); if (multiples_tensor == nullptr) { diff --git a/mindspore/lite/src/ops/compat/v0/topk_compat_v0.cc b/mindspore/lite/src/ops/compat/v0/topk_compat_v0.cc index 48ce7bd234..a3d89e7dd0 100644 --- a/mindspore/lite/src/ops/compat/v0/topk_compat_v0.cc +++ b/mindspore/lite/src/ops/compat/v0/topk_compat_v0.cc @@ -30,7 +30,13 @@ int TransferTopkAttr(Model::Node *node, std::vector *dst_tenso } MS_ASSERT(dst_tensors->size() == 0); auto prim = reinterpret_cast(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."; diff --git a/mindspore/lite/src/ops/compat/v0/transpose_compat_v0.cc b/mindspore/lite/src/ops/compat/v0/transpose_compat_v0.cc index b833e9659f..3e722498d2 100644 --- a/mindspore/lite/src/ops/compat/v0/transpose_compat_v0.cc +++ b/mindspore/lite/src/ops/compat/v0/transpose_compat_v0.cc @@ -31,7 +31,17 @@ int TransferTransposeAttr(Model::Node *node, std::vector *dst_ } dst_tensors->clear(); auto prim = reinterpret_cast(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 dst_shape = std::vector(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) { diff --git a/mindspore/lite/src/ops/populate/activation_grad_populate.cc b/mindspore/lite/src/ops/populate/activation_grad_populate.cc index cf25f440fd..9d3145df4c 100644 --- a/mindspore/lite/src/ops/populate/activation_grad_populate.cc +++ b/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(malloc(sizeof(ActivationGradParameter))); + auto *act_param = reinterpret_cast(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(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(value->activation_type()); act_param->alpha_ = value->alpha(); diff --git a/mindspore/lite/src/ops/populate/activation_populate.cc b/mindspore/lite/src/ops/populate/activation_populate.cc index 3906f90b83..73ee9fa91c 100644 --- a/mindspore/lite/src/ops/populate/activation_populate.cc +++ b/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(malloc(sizeof(ActivationParameter))); + auto *act_param = reinterpret_cast(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(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(acti_prim->activation_type()); act_param->alpha_ = acti_prim->alpha(); act_param->min_val_ = acti_prim->min_val(); diff --git a/mindspore/lite/src/ops/populate/adam_populate.cc b/mindspore/lite/src/ops/populate/adam_populate.cc index 61e6cc4151..981821a5bd 100644 --- a/mindspore/lite/src/ops/populate/adam_populate.cc +++ b/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(malloc(sizeof(OpParameter))); + auto *param = reinterpret_cast(malloc(sizeof(OpParameter))); if (param == nullptr) { MS_LOG(ERROR) << "malloc Adam Parameter failed."; return nullptr; } memset(param, 0, sizeof(OpParameter)); auto primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); param->type_ = primitive->value_type(); return param; } diff --git a/mindspore/lite/src/ops/populate/add_populate.cc b/mindspore/lite/src/ops/populate/add_populate.cc index 300a288ce8..eaa56fc46c 100644 --- a/mindspore/lite/src/ops/populate/add_populate.cc +++ b/mindspore/lite/src/ops/populate/add_populate.cc @@ -30,6 +30,10 @@ OpParameter *PopulateAddParameter(const void *prim) { auto *primitive = static_cast(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(param); } diff --git a/mindspore/lite/src/ops/populate/adder_populate.cc b/mindspore/lite/src/ops/populate/adder_populate.cc index b63977222c..e2a1953d9e 100644 --- a/mindspore/lite/src/ops/populate/adder_populate.cc +++ b/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(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(*(conv_primitive->kernel_size()->begin())); - conv_param->kernel_w_ = static_cast(*(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(*(kernel_size->begin())); + conv_param->kernel_w_ = static_cast(*(kernel_size->begin() + 1)); conv_param->group_ = static_cast(conv_primitive->group()); - conv_param->stride_h_ = static_cast(*(conv_primitive->stride()->begin())); - conv_param->stride_w_ = static_cast(*(conv_primitive->stride()->begin() + 1)); - conv_param->pad_u_ = static_cast(*(conv_primitive->pad_list()->begin())); - conv_param->pad_d_ = static_cast(*(conv_primitive->pad_list()->begin() + 1)); - conv_param->pad_l_ = static_cast(*(conv_primitive->pad_list()->begin() + 2)); - conv_param->pad_r_ = static_cast(*(conv_primitive->pad_list()->begin() + 3)); - conv_param->dilation_h_ = static_cast(*(conv_primitive->dilation()->begin())); - conv_param->dilation_w_ = static_cast(*(conv_primitive->dilation()->begin() + 1)); + conv_param->stride_h_ = static_cast(*(stride->begin())); + conv_param->stride_w_ = static_cast(*(stride->begin() + 1)); + conv_param->pad_u_ = static_cast(*(pad_list->begin())); + conv_param->pad_d_ = static_cast(*(pad_list->begin() + 1)); + conv_param->pad_l_ = static_cast(*(pad_list->begin() + 2)); + conv_param->pad_r_ = static_cast(*(pad_list->begin() + 3)); + conv_param->dilation_h_ = static_cast(*(dilation->begin())); + conv_param->dilation_w_ = static_cast(*(dilation->begin() + 1)); conv_param->input_channel_ = static_cast(conv_primitive->in_channel()); conv_param->output_channel_ = static_cast(conv_primitive->out_channel()); auto act_type = conv_primitive->activation_type(); diff --git a/mindspore/lite/src/ops/populate/addn_populate.cc b/mindspore/lite/src/ops/populate/addn_populate.cc index 4fc98b12b5..e52041d71e 100644 --- a/mindspore/lite/src/ops/populate/addn_populate.cc +++ b/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(malloc(sizeof(OpParameter))); + auto *addn_param = reinterpret_cast(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(prim); + MS_ASSERT(primitive != nullptr); addn_param->type_ = primitive->value_type(); return reinterpret_cast(addn_param); } diff --git a/mindspore/lite/src/ops/populate/argmax_populate.cc b/mindspore/lite/src/ops/populate/argmax_populate.cc index 3e322ade73..baf8aad96e 100644 --- a/mindspore/lite/src/ops/populate/argmax_populate.cc +++ b/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(malloc(sizeof(ArgMinMaxParameter))); + auto *arg_param = reinterpret_cast(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(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(); diff --git a/mindspore/lite/src/ops/populate/argmin_populate.cc b/mindspore/lite/src/ops/populate/argmin_populate.cc index f56fd49e24..19e0106c07 100644 --- a/mindspore/lite/src/ops/populate/argmin_populate.cc +++ b/mindspore/lite/src/ops/populate/argmin_populate.cc @@ -30,6 +30,10 @@ OpParameter *PopulateArgMinParameter(const void *prim) { auto *primitive = static_cast(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(); diff --git a/mindspore/lite/src/ops/populate/arithmetic_populate.cc b/mindspore/lite/src/ops/populate/arithmetic_populate.cc index f646543b35..e2f4f12e4d 100644 --- a/mindspore/lite/src/ops/populate/arithmetic_populate.cc +++ b/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(malloc(sizeof(ArithmeticParameter))); + auto *param = reinterpret_cast(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(prim); + auto *primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); param->op_parameter_.type_ = primitive->value_type(); param->broadcasting_ = false; param->ndim_ = 0; diff --git a/mindspore/lite/src/ops/populate/arithmetic_self_populate.cc b/mindspore/lite/src/ops/populate/arithmetic_self_populate.cc index dad40f5b50..3f3fdc9584 100644 --- a/mindspore/lite/src/ops/populate/arithmetic_self_populate.cc +++ b/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(malloc(sizeof(ArithmeticSelfParameter))); + auto *arithmetic_self_param = reinterpret_cast(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(prim); + auto *primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); arithmetic_self_param->op_parameter_.type_ = primitive->value_type(); return reinterpret_cast(arithmetic_self_param); } diff --git a/mindspore/lite/src/ops/populate/assert_populate.cc b/mindspore/lite/src/ops/populate/assert_populate.cc index 2fa8c5e6df..891fbef8da 100644 --- a/mindspore/lite/src/ops/populate/assert_populate.cc +++ b/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(malloc(sizeof(OpParameter))); + auto *assert_parameter = reinterpret_cast(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(prim); + MS_ASSERT(primitive != nullptr); assert_parameter->type_ = primitive->value_type(); return reinterpret_cast(assert_parameter); diff --git a/mindspore/lite/src/ops/populate/assign_add_populate.cc b/mindspore/lite/src/ops/populate/assign_add_populate.cc index cd30b00c5d..c8f0b72085 100644 --- a/mindspore/lite/src/ops/populate/assign_add_populate.cc +++ b/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(malloc(sizeof(OpParameter))); + auto *param = reinterpret_cast(malloc(sizeof(OpParameter))); if (param == nullptr) { MS_LOG(ERROR) << "malloc AssignAdd Parameter failed."; return nullptr; } memset(param, 0, sizeof(OpParameter)); auto primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); param->type_ = primitive->value_type(); return param; } diff --git a/mindspore/lite/src/ops/populate/assign_populate.cc b/mindspore/lite/src/ops/populate/assign_populate.cc index c20951541a..c5c72dfa0c 100644 --- a/mindspore/lite/src/ops/populate/assign_populate.cc +++ b/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(malloc(sizeof(OpParameter))); + auto *param = reinterpret_cast(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(prim); + MS_ASSERT(primitive != nullptr); param->type_ = primitive->value_type(); return param; } diff --git a/mindspore/lite/src/ops/populate/audio_spectrogram_populate.cc b/mindspore/lite/src/ops/populate/audio_spectrogram_populate.cc index 64e1d2dfb6..684fa5f8ab 100644 --- a/mindspore/lite/src/ops/populate/audio_spectrogram_populate.cc +++ b/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(malloc(sizeof(AudioSpectrogramParameter))); + auto *arg_param = reinterpret_cast(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(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(arg_param); diff --git a/mindspore/lite/src/ops/populate/batch_norm_populate.cc b/mindspore/lite/src/ops/populate/batch_norm_populate.cc index d5a8abf5d3..803933932a 100644 --- a/mindspore/lite/src/ops/populate/batch_norm_populate.cc +++ b/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(malloc(sizeof(BatchNormParameter))); + auto *batch_norm_param = reinterpret_cast(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(prim); + auto *primitive = static_cast(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(batch_norm_param); diff --git a/mindspore/lite/src/ops/populate/batch_to_space_populate.cc b/mindspore/lite/src/ops/populate/batch_to_space_populate.cc index 387ed781e9..26a95b0f94 100644 --- a/mindspore/lite/src/ops/populate/batch_to_space_populate.cc +++ b/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(malloc(sizeof(BatchToSpaceParameter))); + auto *batch_space_param = reinterpret_cast(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(prim); + auto *primitive = static_cast(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(batch_space_param); } - auto block_shape = std::vector(param->block_size()->begin(), param->block_size()->end()); + auto block_shape = std::vector(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 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(crops_data->begin(), crops_data->end()); crops.insert(crops.end(), crops_vec.begin(), crops_vec.end()); } diff --git a/mindspore/lite/src/ops/populate/bias_add_populate.cc b/mindspore/lite/src/ops/populate/bias_add_populate.cc index 97f4bd005b..5ced8d13ac 100644 --- a/mindspore/lite/src/ops/populate/bias_add_populate.cc +++ b/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(malloc(sizeof(ArithmeticParameter))); + auto *arithmetic_param = reinterpret_cast(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(prim); + auto *primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); arithmetic_param->op_parameter_.type_ = primitive->value_type(); return reinterpret_cast(arithmetic_param); diff --git a/mindspore/lite/src/ops/populate/bias_grad_populate.cc b/mindspore/lite/src/ops/populate/bias_grad_populate.cc index 1caae879e8..1127f76e80 100644 --- a/mindspore/lite/src/ops/populate/bias_grad_populate.cc +++ b/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(malloc(sizeof(ArithmeticParameter))); + auto *arithmetic_param = reinterpret_cast(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(prim); + MS_ASSERT(primitive != nullptr); arithmetic_param->op_parameter_.type_ = primitive->value_type(); return reinterpret_cast(arithmetic_param); } diff --git a/mindspore/lite/src/ops/populate/binary_cross_entropy_grad_populate.cc b/mindspore/lite/src/ops/populate/binary_cross_entropy_grad_populate.cc index b681bf05ca..b94ecf7290 100644 --- a/mindspore/lite/src/ops/populate/binary_cross_entropy_grad_populate.cc +++ b/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(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(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(bce_param); } diff --git a/mindspore/lite/src/ops/populate/binary_cross_entropy_populate.cc b/mindspore/lite/src/ops/populate/binary_cross_entropy_populate.cc index 1c90d4c985..f4fb6e74ee 100644 --- a/mindspore/lite/src/ops/populate/binary_cross_entropy_populate.cc +++ b/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(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(bce_param); diff --git a/mindspore/lite/src/ops/populate/broadcast_to_populate.cc b/mindspore/lite/src/ops/populate/broadcast_to_populate.cc index 427c74d184..6c1188ed20 100644 --- a/mindspore/lite/src/ops/populate/broadcast_to_populate.cc +++ b/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(malloc(sizeof(BroadcastToParameter))); + auto *broadcast_param = reinterpret_cast(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(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); diff --git a/mindspore/lite/src/ops/populate/cast_populate.cc b/mindspore/lite/src/ops/populate/cast_populate.cc index 89059e4729..700b0a808e 100644 --- a/mindspore/lite/src/ops/populate/cast_populate.cc +++ b/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(malloc(sizeof(OpParameter))); + auto *cast_param = reinterpret_cast(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(prim); + MS_ASSERT(primitive != nullptr); cast_param->type_ = primitive->value_type(); return reinterpret_cast(cast_param); } diff --git a/mindspore/lite/src/ops/populate/clip_populate.cc b/mindspore/lite/src/ops/populate/clip_populate.cc index c2b7694af9..fba98b4543 100644 --- a/mindspore/lite/src/ops/populate/clip_populate.cc +++ b/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(malloc(sizeof(OpParameter))); + auto *act_param = reinterpret_cast(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(prim); + MS_ASSERT(primitive != nullptr); act_param->type_ = primitive->value_type(); return reinterpret_cast(act_param); } diff --git a/mindspore/lite/src/ops/populate/common_populate.cc b/mindspore/lite/src/ops/populate/common_populate.cc index 55bb3871f2..47c36caeb2 100644 --- a/mindspore/lite/src/ops/populate/common_populate.cc +++ b/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(prim); + MS_ASSERT(primitive != nullptr); common_parameter->type_ = primitive->value_type(); return common_parameter; } diff --git a/mindspore/lite/src/ops/populate/concat_populate.cc b/mindspore/lite/src/ops/populate/concat_populate.cc index c60e9dd0ae..eb30eaa078 100644 --- a/mindspore/lite/src/ops/populate/concat_populate.cc +++ b/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(malloc(sizeof(ConcatParameter))); + auto *concat_param = reinterpret_cast(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(prim); + auto *primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); concat_param->op_parameter_.type_ = primitive->value_type(); - concat_param->axis_ = static_cast(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(param->axis()); return reinterpret_cast(concat_param); } } // namespace diff --git a/mindspore/lite/src/ops/populate/constant_of_shape_populate.cc b/mindspore/lite/src/ops/populate/constant_of_shape_populate.cc index 21acc21e70..a6cda684ab 100644 --- a/mindspore/lite/src/ops/populate/constant_of_shape_populate.cc +++ b/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(malloc(sizeof(ConstantOfShapeParameter))); + auto *param = reinterpret_cast(malloc(sizeof(ConstantOfShapeParameter))); if (param == nullptr) { MS_LOG(ERROR) << "malloc ConstantOfShapeParameter failed."; return nullptr; } memset(param, 0, sizeof(ConstantOfShapeParameter)); auto primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); param->op_parameter_.type_ = primitive->value_type(); auto attr = primitive->value_as_ConstantOfShape(); - auto value = std::vector(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(val->begin(), val->end()); param->data_type_ = static_cast(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"; diff --git a/mindspore/lite/src/ops/populate/conv2d_populate.cc b/mindspore/lite/src/ops/populate/conv2d_populate.cc index d487efee69..edb9b54531 100644 --- a/mindspore/lite/src/ops/populate/conv2d_populate.cc +++ b/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(malloc(sizeof(ConvParameter))); + auto *conv_param = reinterpret_cast(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(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(*(conv_primitive->kernel_size()->begin())); - conv_param->kernel_w_ = static_cast(*(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(*(kernel_size->begin())); + conv_param->kernel_w_ = static_cast(*(kernel_size->begin() + 1)); conv_param->group_ = static_cast(conv_primitive->group()); - conv_param->stride_h_ = static_cast(*(conv_primitive->stride()->begin())); - conv_param->stride_w_ = static_cast(*(conv_primitive->stride()->begin() + 1)); + conv_param->stride_h_ = static_cast(*(stride->begin())); + conv_param->stride_w_ = static_cast(*(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(*(conv_primitive->pad_list()->begin())); - conv_param->pad_d_ = static_cast(*(conv_primitive->pad_list()->begin() + 1)); - conv_param->pad_l_ = static_cast(*(conv_primitive->pad_list()->begin() + 2)); - conv_param->pad_r_ = static_cast(*(conv_primitive->pad_list()->begin() + 3)); + conv_param->pad_u_ = static_cast(*(pad_list->begin())); + conv_param->pad_d_ = static_cast(*(pad_list->begin() + 1)); + conv_param->pad_l_ = static_cast(*(pad_list->begin() + 2)); + conv_param->pad_r_ = static_cast(*(pad_list->begin() + 3)); } - conv_param->dilation_h_ = static_cast(*(conv_primitive->dilation()->begin())); - conv_param->dilation_w_ = static_cast(*(conv_primitive->dilation()->begin() + 1)); + conv_param->dilation_h_ = static_cast(*(dilation->begin())); + conv_param->dilation_w_ = static_cast(*(dilation->begin() + 1)); conv_param->input_channel_ = static_cast(conv_primitive->in_channel()); conv_param->output_channel_ = static_cast(conv_primitive->out_channel()); auto act_type = conv_primitive->activation_type(); diff --git a/mindspore/lite/src/ops/populate/crop_and_resize_populate.cc b/mindspore/lite/src/ops/populate/crop_and_resize_populate.cc index 73534795a6..3c35dea395 100644 --- a/mindspore/lite/src/ops/populate/crop_and_resize_populate.cc +++ b/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(malloc(sizeof(CropAndResizeParameter))); + auto *crop_resize_param = reinterpret_cast(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(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(param->method()); crop_resize_param->extrapolation_value_ = param->extrapolation_value(); return reinterpret_cast(crop_resize_param); diff --git a/mindspore/lite/src/ops/populate/crop_populate.cc b/mindspore/lite/src/ops/populate/crop_populate.cc index 1d5660270b..f14258821e 100644 --- a/mindspore/lite/src/ops/populate/crop_populate.cc +++ b/mindspore/lite/src/ops/populate/crop_populate.cc @@ -22,13 +22,22 @@ namespace lite { namespace { OpParameter *PopulateCropParameter(const void *prim) { auto primitive = static_cast(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(malloc(sizeof(CropParameter))); + auto *crop_param = reinterpret_cast(malloc(sizeof(CropParameter))); if (crop_param == nullptr) { MS_LOG(ERROR) << "malloc CropParameter failed."; return nullptr; diff --git a/mindspore/lite/src/ops/populate/custom_extract_features_populate.cc b/mindspore/lite/src/ops/populate/custom_extract_features_populate.cc index 73b652c2c3..91ecc51594 100644 --- a/mindspore/lite/src/ops/populate/custom_extract_features_populate.cc +++ b/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(malloc(sizeof(OpParameter))); + auto *param = reinterpret_cast(malloc(sizeof(OpParameter))); if (param == nullptr) { MS_LOG(ERROR) << "new OpParameter failed."; return nullptr; } memset(param, 0, sizeof(OpParameter)); auto primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); param->type_ = primitive->value_type(); return param; } diff --git a/mindspore/lite/src/ops/populate/custom_normalize_populate.cc b/mindspore/lite/src/ops/populate/custom_normalize_populate.cc index 93427a2f38..dc85451008 100644 --- a/mindspore/lite/src/ops/populate/custom_normalize_populate.cc +++ b/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(malloc(sizeof(OpParameter))); + auto *param = reinterpret_cast(malloc(sizeof(OpParameter))); if (param == nullptr) { MS_LOG(ERROR) << "new OpParameter failed."; return nullptr; } memset(param, 0, sizeof(OpParameter)); auto primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); param->type_ = primitive->value_type(); return param; } diff --git a/mindspore/lite/src/ops/populate/custom_predict_populate.cc b/mindspore/lite/src/ops/populate/custom_predict_populate.cc index 6fe70800bf..17e693868c 100644 --- a/mindspore/lite/src/ops/populate/custom_predict_populate.cc +++ b/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(malloc(sizeof(PredictParameter))); if (param == nullptr) { @@ -28,7 +27,12 @@ OpParameter *PopulateCustomPredictParameter(const void *prim) { } memset(param, 0, sizeof(PredictParameter)); auto primitive = static_cast(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(); diff --git a/mindspore/lite/src/ops/populate/deconv2d_populate.cc b/mindspore/lite/src/ops/populate/deconv2d_populate.cc index b6d6237c1a..dc82232427 100644 --- a/mindspore/lite/src/ops/populate/deconv2d_populate.cc +++ b/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(malloc(sizeof(ConvParameter))); + auto *conv_param = reinterpret_cast(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(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(*(conv_primitive->kernel_size()->begin())); - conv_param->kernel_w_ = static_cast(*(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(*(kernel_size->begin())); + conv_param->kernel_w_ = static_cast(*(kernel_size->begin() + 1)); conv_param->group_ = static_cast(conv_primitive->group()); - conv_param->stride_h_ = static_cast(*(conv_primitive->stride()->begin())); - conv_param->stride_w_ = static_cast(*(conv_primitive->stride()->begin() + 1)); - conv_param->output_padding_h_ = static_cast(*(conv_primitive->output_paddings()->begin())); - conv_param->output_padding_w_ = static_cast(*(conv_primitive->output_paddings()->begin() + 1)); + conv_param->stride_h_ = static_cast(*(stride->begin())); + conv_param->stride_w_ = static_cast(*(stride->begin() + 1)); + conv_param->output_padding_h_ = static_cast(*(output_paddings->begin())); + conv_param->output_padding_w_ = static_cast(*(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(*(conv_primitive->pad_list()->begin())); - conv_param->pad_d_ = static_cast(*(conv_primitive->pad_list()->begin() + 1)); - conv_param->pad_l_ = static_cast(*(conv_primitive->pad_list()->begin() + 2)); - conv_param->pad_r_ = static_cast(*(conv_primitive->pad_list()->begin() + 3)); + conv_param->pad_u_ = static_cast(*(pad_list->begin())); + conv_param->pad_d_ = static_cast(*(pad_list->begin() + 1)); + conv_param->pad_l_ = static_cast(*(pad_list->begin() + 2)); + conv_param->pad_r_ = static_cast(*(pad_list->begin() + 3)); } - conv_param->dilation_h_ = static_cast(*(conv_primitive->dilation()->begin())); - conv_param->dilation_w_ = static_cast(*(conv_primitive->dilation()->begin() + 1)); + conv_param->dilation_h_ = static_cast(*(dilation->begin())); + conv_param->dilation_w_ = static_cast(*(dilation->begin() + 1)); conv_param->input_channel_ = static_cast(conv_primitive->in_channel()); conv_param->output_channel_ = static_cast(conv_primitive->out_channel()); auto act_type = conv_primitive->activation_type(); diff --git a/mindspore/lite/src/ops/populate/dedepthwise_conv2d_populate.cc b/mindspore/lite/src/ops/populate/dedepthwise_conv2d_populate.cc deleted file mode 100644 index 332f4582c9..0000000000 --- a/mindspore/lite/src/ops/populate/dedepthwise_conv2d_populate.cc +++ /dev/null @@ -1,61 +0,0 @@ -/** - * Copyright 2019-2021 Huawei Technologies Co., Ltd - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -#include "src/ops/populate/populate_register.h" -#include "nnacl/conv_parameter.h" - -namespace mindspore { -namespace lite { -/* -OpParameter *PopulateDeconvDwParameter(const mindspore::lite::PrimitiveC *primitive) { - ConvParameter *conv_param = reinterpret_cast(malloc(sizeof(ConvParameter))); - if (conv_param == nullptr) { - MS_LOG(ERROR) << "malloc ConvParameter failed."; - return nullptr; - } - memset(conv_param, 0, sizeof(ConvParameter)); - conv_param->op_parameter_.type_ = primitive->Type(); - auto conv_primitive = - reinterpret_cast(const_cast(primitive)); - conv_param->kernel_h_ = conv_primitive->GetKernelH(); - conv_param->kernel_w_ = conv_primitive->GetKernelW(); - conv_param->stride_h_ = conv_primitive->GetStrideH(); - conv_param->stride_w_ = conv_primitive->GetStrideW(); - - auto deconvdw_lite_primitive = (mindspore::lite::DeDepthwiseConv2D *)primitive; - conv_param->pad_u_ = deconvdw_lite_primitive->PadUp(); - conv_param->pad_d_ = deconvdw_lite_primitive->PadDown(); - conv_param->pad_l_ = deconvdw_lite_primitive->PadLeft(); - conv_param->pad_r_ = deconvdw_lite_primitive->PadRight(); - conv_param->dilation_h_ = conv_primitive->GetDilateH(); - conv_param->dilation_w_ = conv_primitive->GetDilateW(); - auto act_type = conv_primitive->GetActivationType(); - switch (act_type) { - case schema::ActivationType_RELU: - conv_param->act_type_ = ActType_Relu; - break; - case schema::ActivationType_RELU6: - conv_param->act_type_ = ActType_Relu6; - break; - default: - conv_param->act_type_ = ActType_No; - break; - } - return reinterpret_cast(conv_param); -} - -*/ -} // namespace lite -} // namespace mindspore diff --git a/mindspore/lite/src/ops/populate/default_populate.cc b/mindspore/lite/src/ops/populate/default_populate.cc index faac1397ca..6e30c41b30 100644 --- a/mindspore/lite/src/ops/populate/default_populate.cc +++ b/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(malloc(sizeof(OpParameter))); + auto *param = static_cast(malloc(sizeof(OpParameter))); if (param == nullptr) { MS_LOG(ERROR) << "Malloc OpParameter failed."; return nullptr; } memset(param, 0, sizeof(OpParameter)); auto *primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); param->type_ = primitive->value_type(); return param; } diff --git a/mindspore/lite/src/ops/populate/depth_to_space_populate.cc b/mindspore/lite/src/ops/populate/depth_to_space_populate.cc index 27df69abab..144a2fe746 100644 --- a/mindspore/lite/src/ops/populate/depth_to_space_populate.cc +++ b/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(malloc(sizeof(DepthToSpaceParameter))); + auto *depth_space_param = reinterpret_cast(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(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(depth_space_param); diff --git a/mindspore/lite/src/ops/populate/depthwise_conv2d_populate.cc b/mindspore/lite/src/ops/populate/depthwise_conv2d_populate.cc index 387561ea23..21be649792 100644 --- a/mindspore/lite/src/ops/populate/depthwise_conv2d_populate.cc +++ b/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(malloc(sizeof(ConvParameter))); + auto *conv_param = reinterpret_cast(malloc(sizeof(ConvParameter))); if (conv_param == nullptr) { MS_LOG(ERROR) << "malloc ConvParameter failed."; return nullptr; diff --git a/mindspore/lite/src/ops/populate/detection_post_process_populate.cc b/mindspore/lite/src/ops/populate/detection_post_process_populate.cc index db22340839..20ad515018 100644 --- a/mindspore/lite/src/ops/populate/detection_post_process_populate.cc +++ b/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(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(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(); diff --git a/mindspore/lite/src/ops/populate/div_populate.cc b/mindspore/lite/src/ops/populate/div_populate.cc index b686fc1c4a..fef701b4f8 100644 --- a/mindspore/lite/src/ops/populate/div_populate.cc +++ b/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; diff --git a/mindspore/lite/src/ops/populate/eltwise_populate.cc b/mindspore/lite/src/ops/populate/eltwise_populate.cc index 5b4b2d731f..c416bc1c22 100644 --- a/mindspore/lite/src/ops/populate/eltwise_populate.cc +++ b/mindspore/lite/src/ops/populate/eltwise_populate.cc @@ -27,7 +27,13 @@ OpParameter *PopulateEltwiseParameter(const void *prim) { return nullptr; } auto primitive = static_cast(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(param); } } // namespace diff --git a/mindspore/lite/src/ops/populate/elu_populate.cc b/mindspore/lite/src/ops/populate/elu_populate.cc index c99c275e03..897da96e28 100644 --- a/mindspore/lite/src/ops/populate/elu_populate.cc +++ b/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(malloc(sizeof(EluParameter))); + auto *elu_parameter = reinterpret_cast(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(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(elu_parameter); } diff --git a/mindspore/lite/src/ops/populate/embedding_lookup_populate.cc b/mindspore/lite/src/ops/populate/embedding_lookup_populate.cc index 95e35e47dd..920d00bd52 100644 --- a/mindspore/lite/src/ops/populate/embedding_lookup_populate.cc +++ b/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(malloc(sizeof(EmbeddingLookupParameter))); + auto *param = reinterpret_cast(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(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) { diff --git a/mindspore/lite/src/ops/populate/exp_populate.cc b/mindspore/lite/src/ops/populate/exp_populate.cc index f7a3e486c0..49d4061bbc 100644 --- a/mindspore/lite/src/ops/populate/exp_populate.cc +++ b/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(malloc(sizeof(ExpParameter))); + auto *exp_parameter = reinterpret_cast(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(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(); diff --git a/mindspore/lite/src/ops/populate/expand_dims_populate.cc b/mindspore/lite/src/ops/populate/expand_dims_populate.cc index b63bf7cf80..75fcacd782 100644 --- a/mindspore/lite/src/ops/populate/expand_dims_populate.cc +++ b/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(malloc(sizeof(OpParameter))); + auto *expand_param = reinterpret_cast(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(prim); + MS_ASSERT(primitive != nullptr); expand_param->type_ = primitive->value_type(); return reinterpret_cast(expand_param); } diff --git a/mindspore/lite/src/ops/populate/fill_populate.cc b/mindspore/lite/src/ops/populate/fill_populate.cc index 725b17f453..4742786619 100644 --- a/mindspore/lite/src/ops/populate/fill_populate.cc +++ b/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(malloc(sizeof(OpParameter))); + auto *fill_param = reinterpret_cast(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(prim); + MS_ASSERT(primitive != nullptr); fill_param->type_ = primitive->value_type(); return reinterpret_cast(fill_param); } diff --git a/mindspore/lite/src/ops/populate/flatten_populate.cc b/mindspore/lite/src/ops/populate/flatten_populate.cc index 1ff2994b80..7cdf366074 100644 --- a/mindspore/lite/src/ops/populate/flatten_populate.cc +++ b/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(malloc(sizeof(OpParameter))); + auto *flatten_param = reinterpret_cast(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(prim); + MS_ASSERT(primitive != nullptr); flatten_param->type_ = primitive->value_type(); return reinterpret_cast(flatten_param); } diff --git a/mindspore/lite/src/ops/populate/full_connection_populate.cc b/mindspore/lite/src/ops/populate/full_connection_populate.cc index b8fdc0afef..2935b55063 100644 --- a/mindspore/lite/src/ops/populate/full_connection_populate.cc +++ b/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(malloc(sizeof(MatMulParameter))); + auto *matmul_param = reinterpret_cast(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(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(); diff --git a/mindspore/lite/src/ops/populate/fused_batchnorm_populate.cc b/mindspore/lite/src/ops/populate/fused_batchnorm_populate.cc index e80ae840cf..3654ea816b 100644 --- a/mindspore/lite/src/ops/populate/fused_batchnorm_populate.cc +++ b/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(malloc(sizeof(BatchNormParameter))); + auto *batch_norm_param = reinterpret_cast(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(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(); diff --git a/mindspore/lite/src/ops/populate/gather_nd_populate.cc b/mindspore/lite/src/ops/populate/gather_nd_populate.cc index 1d78ae613b..5fc5a7d886 100644 --- a/mindspore/lite/src/ops/populate/gather_nd_populate.cc +++ b/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(malloc(sizeof(GatherNdParameter))); + auto *gather_nd_param = reinterpret_cast(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(prim); + MS_ASSERT(primitive != nullptr); gather_nd_param->op_parameter_.type_ = primitive->value_type(); return reinterpret_cast(gather_nd_param); } diff --git a/mindspore/lite/src/ops/populate/gather_populate.cc b/mindspore/lite/src/ops/populate/gather_populate.cc index 73c2ad7568..ab454237ad 100644 --- a/mindspore/lite/src/ops/populate/gather_populate.cc +++ b/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(malloc(sizeof(GatherParameter))); + auto *gather_param = reinterpret_cast(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(prim); + MS_ASSERT(primitive != nullptr); gather_param->op_parameter_.type_ = primitive->value_type(); return reinterpret_cast(gather_param); diff --git a/mindspore/lite/src/ops/populate/gru_populate.cc b/mindspore/lite/src/ops/populate/gru_populate.cc index f05e8f31d0..b3a8384c2b 100644 --- a/mindspore/lite/src/ops/populate/gru_populate.cc +++ b/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(malloc(sizeof(GruParameter))); + auto *gru_param = reinterpret_cast(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(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(); diff --git a/mindspore/lite/src/ops/populate/hashtable_lookup_populate.cc b/mindspore/lite/src/ops/populate/hashtable_lookup_populate.cc index 164b9611f1..887c4c9b53 100644 --- a/mindspore/lite/src/ops/populate/hashtable_lookup_populate.cc +++ b/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(malloc(sizeof(OpParameter))); + auto *param = reinterpret_cast(malloc(sizeof(OpParameter))); if (param == nullptr) { MS_LOG(ERROR) << "new OpParameter failed."; return nullptr; } memset(param, 0, sizeof(OpParameter)); auto primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); param->type_ = primitive->value_type(); return param; } diff --git a/mindspore/lite/src/ops/populate/instance_norm_populate.cc b/mindspore/lite/src/ops/populate/instance_norm_populate.cc index 56aef044d7..02002deecb 100644 --- a/mindspore/lite/src/ops/populate/instance_norm_populate.cc +++ b/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(malloc(sizeof(InstanceNormParameter))); + auto *instance_norm_param = reinterpret_cast(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(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(instance_norm_param); diff --git a/mindspore/lite/src/ops/populate/l2_norm_populate.cc b/mindspore/lite/src/ops/populate/l2_norm_populate.cc index f3011799dd..16faf70721 100644 --- a/mindspore/lite/src/ops/populate/l2_norm_populate.cc +++ b/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(malloc(sizeof(L2NormParameter))); + auto *l2_norm_parameter = reinterpret_cast(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(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); diff --git a/mindspore/lite/src/ops/populate/layer_norm_grad_populate.cc b/mindspore/lite/src/ops/populate/layer_norm_grad_populate.cc index 57c37be697..0d9583d6ff 100644 --- a/mindspore/lite/src/ops/populate/layer_norm_grad_populate.cc +++ b/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(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(layer_norm_grad_parameter); diff --git a/mindspore/lite/src/ops/populate/layer_norm_populate.cc b/mindspore/lite/src/ops/populate/layer_norm_populate.cc index 24e8288798..73e9f78e40 100644 --- a/mindspore/lite/src/ops/populate/layer_norm_populate.cc +++ b/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(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(param->begin_norm_axis()); diff --git a/mindspore/lite/src/ops/populate/local_response_normalization_populate.cc b/mindspore/lite/src/ops/populate/local_response_normalization_populate.cc index 865ebaf8d3..b26f13fcf2 100644 --- a/mindspore/lite/src/ops/populate/local_response_normalization_populate.cc +++ b/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(malloc(sizeof(LocalResponseNormParameter))); + auto *lrn_param = reinterpret_cast(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(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(); diff --git a/mindspore/lite/src/ops/populate/log_softmax_populate.cc b/mindspore/lite/src/ops/populate/log_softmax_populate.cc index 9a28d31c03..ff7ea1bb12 100644 --- a/mindspore/lite/src/ops/populate/log_softmax_populate.cc +++ b/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(malloc(sizeof(SoftmaxParameter))); + auto *log_softmax_param = reinterpret_cast(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(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(log_softmax_param); } diff --git a/mindspore/lite/src/ops/populate/lsh_projection_populate.cc b/mindspore/lite/src/ops/populate/lsh_projection_populate.cc index cdd5396172..5f9a966e5b 100644 --- a/mindspore/lite/src/ops/populate/lsh_projection_populate.cc +++ b/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(malloc(sizeof(LshProjectionParameter))); + auto *lsh_project_param = reinterpret_cast(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(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(lsh_project_param); diff --git a/mindspore/lite/src/ops/populate/lstm_populate.cc b/mindspore/lite/src/ops/populate/lstm_populate.cc index 54faacf05b..04bd36f4da 100644 --- a/mindspore/lite/src/ops/populate/lstm_populate.cc +++ b/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(malloc(sizeof(LstmParameter))); + auto *lstm_param = reinterpret_cast(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(prim); + MS_ASSERT(primitive != nullptr); lstm_param->op_parameter_.type_ = primitive->value_type(); auto param = primitive->value_as_LSTM(); if (param == nullptr) { diff --git a/mindspore/lite/src/ops/populate/matmul_populate.cc b/mindspore/lite/src/ops/populate/matmul_populate.cc index be0619ab93..167303b962 100644 --- a/mindspore/lite/src/ops/populate/matmul_populate.cc +++ b/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(malloc(sizeof(MatMulParameter))); + auto *matmul_param = reinterpret_cast(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(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(); diff --git a/mindspore/lite/src/ops/populate/merge_populate.cc b/mindspore/lite/src/ops/populate/merge_populate.cc index 4fae7b67e1..59f79b61b1 100644 --- a/mindspore/lite/src/ops/populate/merge_populate.cc +++ b/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(malloc(sizeof(OpParameter))); + auto *merge_parameter = reinterpret_cast(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(prim); + MS_ASSERT(primitive != nullptr); merge_parameter->type_ = primitive->value_type(); return reinterpret_cast(merge_parameter); } diff --git a/mindspore/lite/src/ops/populate/mfcc_populate.cc b/mindspore/lite/src/ops/populate/mfcc_populate.cc index 88bb64bcb1..f133143892 100644 --- a/mindspore/lite/src/ops/populate/mfcc_populate.cc +++ b/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(malloc(sizeof(MfccParameter))); + auto *arg_param = reinterpret_cast(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(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(arg_param); } diff --git a/mindspore/lite/src/ops/populate/mul_populate.cc b/mindspore/lite/src/ops/populate/mul_populate.cc index a9061be48c..3a908974ea 100644 --- a/mindspore/lite/src/ops/populate/mul_populate.cc +++ b/mindspore/lite/src/ops/populate/mul_populate.cc @@ -28,6 +28,7 @@ OpParameter *PopulateMulParameter(const void *prim) { return nullptr; } auto *primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); param->op_parameter_.type_ = primitive->value_type(); return reinterpret_cast(param); } diff --git a/mindspore/lite/src/ops/populate/non_max_suppression_populate.cc b/mindspore/lite/src/ops/populate/non_max_suppression_populate.cc index 8c0f257e9f..4f37f8d3ac 100644 --- a/mindspore/lite/src/ops/populate/non_max_suppression_populate.cc +++ b/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(malloc(sizeof(NMSParameter))); + auto *param = reinterpret_cast(malloc(sizeof(NMSParameter))); if (param == nullptr) { MS_LOG(ERROR) << "malloc param failed."; return nullptr; } memset(param, 0, sizeof(NMSParameter)); auto primitive = static_cast(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(param); diff --git a/mindspore/lite/src/ops/populate/one_hot_populate.cc b/mindspore/lite/src/ops/populate/one_hot_populate.cc index becc6e1a32..588324de64 100644 --- a/mindspore/lite/src/ops/populate/one_hot_populate.cc +++ b/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(malloc(sizeof(OneHotParameter))); + auto *one_hot_param = reinterpret_cast(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(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(one_hot_param); diff --git a/mindspore/lite/src/ops/populate/oneslike_populate.cc b/mindspore/lite/src/ops/populate/oneslike_populate.cc index 9bb3281734..ceb32274da 100644 --- a/mindspore/lite/src/ops/populate/oneslike_populate.cc +++ b/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(malloc(sizeof(OpParameter))); + auto *param = reinterpret_cast(malloc(sizeof(OpParameter))); if (param == nullptr) { MS_LOG(ERROR) << "malloc OnesLike Parameter failed."; return nullptr; } memset(param, 0, sizeof(OpParameter)); auto primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); param->type_ = primitive->value_type(); return param; } diff --git a/mindspore/lite/src/ops/populate/p_relu_populate.cc b/mindspore/lite/src/ops/populate/p_relu_populate.cc index 5d109d00a3..4c5f76d24c 100644 --- a/mindspore/lite/src/ops/populate/p_relu_populate.cc +++ b/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(malloc(sizeof(PReluParameter))); if (param == nullptr) { @@ -28,7 +27,12 @@ OpParameter *PopulatePReLUParameter(const void *prim) { } memset(param, 0, sizeof(PReluParameter)); auto primitive = static_cast(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(param); diff --git a/mindspore/lite/src/ops/populate/pad_populate.cc b/mindspore/lite/src/ops/populate/pad_populate.cc index ae5c16a1e4..4e031f19af 100644 --- a/mindspore/lite/src/ops/populate/pad_populate.cc +++ b/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(malloc(sizeof(PadParameter))); + auto *pad_param = reinterpret_cast(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(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(); diff --git a/mindspore/lite/src/ops/populate/partial_populate.cc b/mindspore/lite/src/ops/populate/partial_populate.cc index 4ff60edffb..e6fc20732b 100644 --- a/mindspore/lite/src/ops/populate/partial_populate.cc +++ b/mindspore/lite/src/ops/populate/partial_populate.cc @@ -24,14 +24,19 @@ typedef struct PartialParameter { } PartialParameter; OpParameter *PopulatePartialParameter(const void *prim) { - PartialParameter *partial_parameter = reinterpret_cast(malloc(sizeof(PartialParameter))); + auto *partial_parameter = reinterpret_cast(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(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(); diff --git a/mindspore/lite/src/ops/populate/pooling_populate.cc b/mindspore/lite/src/ops/populate/pooling_populate.cc index 6eeabe289a..1b935772fc 100644 --- a/mindspore/lite/src/ops/populate/pooling_populate.cc +++ b/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(malloc(sizeof(PoolingParameter))); + auto *pooling_param = reinterpret_cast(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(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(*(pooling_primitive->strides()->begin() + 1)); - pooling_param->stride_h_ = static_cast(*(pooling_primitive->strides()->begin())); - if (pooling_primitive->pad() != nullptr) { - pooling_param->pad_u_ = static_cast(*(pooling_primitive->pad()->begin())); - pooling_param->pad_d_ = static_cast(*(pooling_primitive->pad()->begin() + 1)); - pooling_param->pad_l_ = static_cast(*(pooling_primitive->pad()->begin() + 2)); - pooling_param->pad_r_ = static_cast(*(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(*(strides->begin() + 1)); + pooling_param->stride_h_ = static_cast(*(strides->begin())); + auto pad = pooling_primitive->pad(); + if (pad != nullptr) { + pooling_param->pad_u_ = static_cast(*(pad->begin())); + pooling_param->pad_d_ = static_cast(*(pad->begin() + 1)); + pooling_param->pad_l_ = static_cast(*(pad->begin() + 2)); + pooling_param->pad_r_ = static_cast(*(pad->begin() + 3)); } if (!pooling_param->global_) { - pooling_param->window_w_ = static_cast(*(pooling_primitive->kernel_size()->begin() + 1)); - pooling_param->window_h_ = static_cast(*(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(*(kernel_size->begin() + 1)); + pooling_param->window_h_ = static_cast(*(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(malloc(sizeof(PoolingParameter))); + auto *pooling_param = reinterpret_cast(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(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(*(max_pool_prim->kernel_size()->begin() + 1)); - pooling_param->window_h_ = static_cast(*(max_pool_prim->kernel_size()->begin())); - pooling_param->stride_w_ = static_cast(*(max_pool_prim->strides()->begin() + 1)); - pooling_param->stride_h_ = static_cast(*(max_pool_prim->strides()->begin())); - if (max_pool_prim->pad() != nullptr) { - pooling_param->pad_u_ = static_cast(*(max_pool_prim->pad()->begin())); - pooling_param->pad_d_ = static_cast(*(max_pool_prim->pad()->begin() + 1)); - pooling_param->pad_l_ = static_cast(*(max_pool_prim->pad()->begin() + 2)); - pooling_param->pad_r_ = static_cast(*(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(*(kernel_size->begin() + 1)); + pooling_param->window_h_ = static_cast(*(kernel_size->begin())); + pooling_param->stride_w_ = static_cast(*(strides->begin() + 1)); + pooling_param->stride_h_ = static_cast(*(strides->begin())); + auto pad = max_pool_prim->pad(); + if (pad != nullptr) { + pooling_param->pad_u_ = static_cast(*(pad->begin())); + pooling_param->pad_d_ = static_cast(*(pad->begin() + 1)); + pooling_param->pad_l_ = static_cast(*(pad->begin() + 2)); + pooling_param->pad_r_ = static_cast(*(pad->begin() + 3)); } } diff --git a/mindspore/lite/src/ops/populate/power_populate.cc b/mindspore/lite/src/ops/populate/power_populate.cc index 1a0cc30087..db9d567934 100644 --- a/mindspore/lite/src/ops/populate/power_populate.cc +++ b/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(malloc(sizeof(PowerParameter))); + auto *power_param = reinterpret_cast(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(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(power_param); diff --git a/mindspore/lite/src/ops/populate/prior_box_populate.cc b/mindspore/lite/src/ops/populate/prior_box_populate.cc index 0382499a87..87ec3a07b6 100644 --- a/mindspore/lite/src/ops/populate/prior_box_populate.cc +++ b/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(malloc(sizeof(PriorBoxParameter))); + auto *prior_box_param = reinterpret_cast(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(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(); diff --git a/mindspore/lite/src/ops/populate/quant_dtype_cast_populate.cc b/mindspore/lite/src/ops/populate/quant_dtype_cast_populate.cc index 251e48f7b1..d0a5913659 100644 --- a/mindspore/lite/src/ops/populate/quant_dtype_cast_populate.cc +++ b/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(malloc(sizeof(QuantDTypeCastParameter))); + auto *parameter = reinterpret_cast(malloc(sizeof(QuantDTypeCastParameter))); if (parameter == nullptr) { MS_LOG(ERROR) << "malloc QuantDTypeCastParameter failed."; return nullptr; } memset(parameter, 0, sizeof(QuantDTypeCastParameter)); auto primitive = static_cast(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(); diff --git a/mindspore/lite/src/ops/populate/random_standard_normal_populate.cc b/mindspore/lite/src/ops/populate/random_standard_normal_populate.cc index d19fd37749..446d6d70b9 100644 --- a/mindspore/lite/src/ops/populate/random_standard_normal_populate.cc +++ b/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(malloc(sizeof(RandomParam))); + auto *random_parameter = reinterpret_cast(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(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(random_parameter); diff --git a/mindspore/lite/src/ops/populate/range_populate.cc b/mindspore/lite/src/ops/populate/range_populate.cc index 8fc506a294..3517fa7fcd 100644 --- a/mindspore/lite/src/ops/populate/range_populate.cc +++ b/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(malloc(sizeof(RangeParameter))); + auto *range_param = reinterpret_cast(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(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(); diff --git a/mindspore/lite/src/ops/populate/rank_populate.cc b/mindspore/lite/src/ops/populate/rank_populate.cc index b239e77a55..f0c2e5f3a0 100644 --- a/mindspore/lite/src/ops/populate/rank_populate.cc +++ b/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(malloc(sizeof(OpParameter))); + auto *rank_param = reinterpret_cast(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(prim); + MS_ASSERT(primitive != nullptr); rank_param->type_ = primitive->value_type(); return reinterpret_cast(rank_param); } diff --git a/mindspore/lite/src/ops/populate/reduce_populate.cc b/mindspore/lite/src/ops/populate/reduce_populate.cc index b8b11b8876..bce3524c3e 100644 --- a/mindspore/lite/src/ops/populate/reduce_populate.cc +++ b/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(malloc(sizeof(ReduceParameter))); + auto *reduce_param = reinterpret_cast(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(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(); diff --git a/mindspore/lite/src/ops/populate/reshape_populate.cc b/mindspore/lite/src/ops/populate/reshape_populate.cc index ccf9894626..ebee23e806 100644 --- a/mindspore/lite/src/ops/populate/reshape_populate.cc +++ b/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(malloc(sizeof(ReshapeParameter))); + auto *reshape_param = reinterpret_cast(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(prim); + MS_ASSERT(primitive != nullptr); reshape_param->op_parameter_.type_ = primitive->value_type(); return reinterpret_cast(reshape_param); } diff --git a/mindspore/lite/src/ops/populate/resize_populate.cc b/mindspore/lite/src/ops/populate/resize_populate.cc index 32b3882025..f4c2ca6357 100644 --- a/mindspore/lite/src/ops/populate/resize_populate.cc +++ b/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(malloc(sizeof(ResizeParameter))); + auto *resize_param = reinterpret_cast(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(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(value->method()); diff --git a/mindspore/lite/src/ops/populate/reverse_populate.cc b/mindspore/lite/src/ops/populate/reverse_populate.cc index 281e89e8ca..c70e7bbec5 100644 --- a/mindspore/lite/src/ops/populate/reverse_populate.cc +++ b/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(malloc(sizeof(ReverseParameter))); + auto *reverse_param = reinterpret_cast(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(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++) { diff --git a/mindspore/lite/src/ops/populate/reverse_sequence_populate.cc b/mindspore/lite/src/ops/populate/reverse_sequence_populate.cc index f5b26df147..129d8d9539 100644 --- a/mindspore/lite/src/ops/populate/reverse_sequence_populate.cc +++ b/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(malloc(sizeof(ReverseSequenceParameter))); + auto *reverse_sequence_param = reinterpret_cast(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(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(param->seq_dim()); reverse_sequence_param->batch_axis_ = static_cast(param->batch_dim()); diff --git a/mindspore/lite/src/ops/populate/roi_pooling_populate.cc b/mindspore/lite/src/ops/populate/roi_pooling_populate.cc index 9e9baf9b19..120969f741 100644 --- a/mindspore/lite/src/ops/populate/roi_pooling_populate.cc +++ b/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(malloc(sizeof(ROIPoolingParameter))); + auto *roi_param = reinterpret_cast(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(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(); diff --git a/mindspore/lite/src/ops/populate/scale_populate.cc b/mindspore/lite/src/ops/populate/scale_populate.cc index 5a5de2d721..bfdde39591 100644 --- a/mindspore/lite/src/ops/populate/scale_populate.cc +++ b/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(malloc(sizeof(ScaleParameter))); + auto *scale_param = reinterpret_cast(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(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(); diff --git a/mindspore/lite/src/ops/populate/scatter_nd_populate.cc b/mindspore/lite/src/ops/populate/scatter_nd_populate.cc index 2ef2a1b4dc..f6e4c4b3e7 100644 --- a/mindspore/lite/src/ops/populate/scatter_nd_populate.cc +++ b/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(malloc(sizeof(OpParameter))); + auto *scatter_nd_param = reinterpret_cast(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(prim); + MS_ASSERT(primitive != nullptr); scatter_nd_param->type_ = primitive->value_type(); return reinterpret_cast(scatter_nd_param); } diff --git a/mindspore/lite/src/ops/populate/shape_populate.cc b/mindspore/lite/src/ops/populate/shape_populate.cc index 4dc4ee0854..2cd62c691c 100644 --- a/mindspore/lite/src/ops/populate/shape_populate.cc +++ b/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(malloc(sizeof(OpParameter))); + auto *shape_param = reinterpret_cast(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(prim); + MS_ASSERT(primitive != nullptr); shape_param->type_ = primitive->value_type(); return reinterpret_cast(shape_param); } diff --git a/mindspore/lite/src/ops/populate/skip_gram_populate.cc b/mindspore/lite/src/ops/populate/skip_gram_populate.cc index 54324b8367..4f33ff961f 100644 --- a/mindspore/lite/src/ops/populate/skip_gram_populate.cc +++ b/mindspore/lite/src/ops/populate/skip_gram_populate.cc @@ -19,16 +19,20 @@ using mindspore::schema::PrimitiveType_SkipGram; namespace mindspore { namespace lite { - OpParameter *PopulateSkipGramParameter(const void *prim) { - SkipGramParameter *skipGramParameter = reinterpret_cast(malloc(sizeof(SkipGramParameter))); + auto *skipGramParameter = reinterpret_cast(malloc(sizeof(SkipGramParameter))); if (skipGramParameter == nullptr) { MS_LOG(ERROR) << "malloc SkipGramParameter failed."; return nullptr; } memset(skipGramParameter, 0, sizeof(SkipGramParameter)); auto primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); auto value = primitive->value_as_SkipGram(); + if (value == nullptr) { + MS_LOG(ERROR) << "value is nullptr"; + return nullptr; + } skipGramParameter->op_parameter_.type_ = primitive->value_type(); skipGramParameter->ngram_size = value->ngram_size(); skipGramParameter->max_skip_size = value->max_skip_size(); diff --git a/mindspore/lite/src/ops/populate/slice_populate.cc b/mindspore/lite/src/ops/populate/slice_populate.cc index 3003ab6162..3be4f9962e 100644 --- a/mindspore/lite/src/ops/populate/slice_populate.cc +++ b/mindspore/lite/src/ops/populate/slice_populate.cc @@ -19,19 +19,28 @@ using mindspore::schema::PrimitiveType_SliceFusion; namespace mindspore { namespace lite { - OpParameter *PopulateSliceParameter(const void *prim) { - SliceParameter *slice_param = reinterpret_cast(malloc(sizeof(SliceParameter))); + auto *slice_param = reinterpret_cast(malloc(sizeof(SliceParameter))); if (slice_param == nullptr) { MS_LOG(ERROR) << "malloc SliceParameter failed."; return nullptr; } memset(slice_param, 0, sizeof(SliceParameter)); auto primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); auto value = primitive->value_as_SliceFusion(); + if (value == nullptr) { + MS_LOG(ERROR) << "value is nullptr"; + return nullptr; + } slice_param->op_parameter_.type_ = primitive->value_type(); - for (size_t i = 0; i < value->axes()->size(); ++i) { - slice_param->axis_[i] = value->axes()->Get(i); + auto axes = value->axes(); + if (axes == nullptr) { + MS_LOG(ERROR) << "axes is nullptr"; + return nullptr; + } + for (size_t i = 0; i < axes->size(); ++i) { + slice_param->axis_[i] = axes->Get(i); } return reinterpret_cast(slice_param); } diff --git a/mindspore/lite/src/ops/populate/softmax_populate.cc b/mindspore/lite/src/ops/populate/softmax_populate.cc index e05d872c58..f3c0f7febf 100644 --- a/mindspore/lite/src/ops/populate/softmax_populate.cc +++ b/mindspore/lite/src/ops/populate/softmax_populate.cc @@ -21,21 +21,31 @@ namespace mindspore { namespace lite { namespace { OpParameter *PopulateSoftmaxParameter(const void *prim) { - SoftmaxParameter *softmax_param = reinterpret_cast(malloc(sizeof(SoftmaxParameter))); + auto *softmax_param = reinterpret_cast(malloc(sizeof(SoftmaxParameter))); if (softmax_param == nullptr) { MS_LOG(ERROR) << "malloc SoftmaxParameter failed."; return nullptr; } memset(softmax_param, 0, sizeof(SoftmaxParameter)); auto primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); softmax_param->op_parameter_.type_ = primitive->value_type(); auto prim_softmax = primitive->value_as_Softmax(); - if (prim_softmax->axis()->size() != 1) { - MS_LOG(ERROR) << "axis number invalid!number: " << prim_softmax->axis()->size(); + if (prim_softmax == nullptr) { + MS_LOG(ERROR) << "prim_softmax is nullptr"; + return nullptr; + } + auto axis = prim_softmax->axis(); + if (axis == nullptr) { + MS_LOG(ERROR) << "axis is nullptr"; + return nullptr; + } + if (axis->size() != 1) { + MS_LOG(ERROR) << "axis number invalid!number: " << axis->size(); free(softmax_param); return nullptr; } - softmax_param->axis_ = prim_softmax->axis()->data()[0]; + softmax_param->axis_ = axis->data()[0]; return reinterpret_cast(softmax_param); } } // namespace diff --git a/mindspore/lite/src/ops/populate/space_to_batch_nd_populate.cc b/mindspore/lite/src/ops/populate/space_to_batch_nd_populate.cc index e740f235e3..a8d81f4122 100644 --- a/mindspore/lite/src/ops/populate/space_to_batch_nd_populate.cc +++ b/mindspore/lite/src/ops/populate/space_to_batch_nd_populate.cc @@ -27,13 +27,19 @@ OpParameter *PopulateSpaceToBatchNDParameter(const void *prim) { return nullptr; } memset(space_batch_param_nd, 0, sizeof(SpaceToBatchParameter)); - const schema::Primitive *primitive = static_cast(prim); + auto *primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); space_batch_param_nd->op_parameter_.type_ = primitive->value_type(); auto param = primitive->value_as_SpaceToBatchND(); - if (param->block_shape() == nullptr) { + if (param == nullptr) { + MS_LOG(ERROR) << "param is nullptr"; + return nullptr; + } + auto block_shape = param->block_shape(); + if (block_shape == nullptr) { return reinterpret_cast(space_batch_param_nd); } - auto block_shapes = std::vector(param->block_shape()->begin(), param->block_shape()->end()); + auto block_shapes = std::vector(block_shape->begin(), block_shape->end()); if (block_shapes.size() > std::numeric_limits::max() / sizeof(int)) { MS_LOG(ERROR) << "The value of block_shapes.size() is too big"; free(space_batch_param_nd); @@ -41,10 +47,20 @@ OpParameter *PopulateSpaceToBatchNDParameter(const void *prim) { } space_batch_param_nd->m_ = block_shapes.size(); - auto fb_paddings = param->paddings()->data(); + auto param_paddings = param->paddings(); + if (param_paddings == nullptr) { + MS_LOG(ERROR) << "param_paddings is nullptr"; + return nullptr; + } + auto fb_paddings = param_paddings->data(); + if (fb_paddings == nullptr) { + MS_LOG(ERROR) << "fb_paddings is nullptr"; + return nullptr; + } if (fb_paddings->size() == 0 || - static_cast(fb_paddings->size() * (*(fb_paddings->begin()))->data()->size()) > - std::numeric_limits::max() / sizeof(int64_t)) { + ((*(fb_paddings->begin())) != nullptr && (*(fb_paddings->begin()))->data() != nullptr && + static_cast(fb_paddings->size() * (*(fb_paddings->begin()))->data()->size()) > + std::numeric_limits::max() / sizeof(int64_t))) { MS_LOG(ERROR) << "The value of paddings.size() is zero or too big"; free(space_batch_param_nd); return nullptr; @@ -52,6 +68,10 @@ OpParameter *PopulateSpaceToBatchNDParameter(const void *prim) { std::vector paddings; for (auto iter = fb_paddings->begin(); iter != fb_paddings->end(); ++iter) { auto paddings_data = (*iter)->data(); + if (paddings_data == nullptr) { + MS_LOG(ERROR) << "paddings_data is nullptr"; + return nullptr; + } auto paddings_vec = std::vector(paddings_data->begin(), paddings_data->end()); paddings.insert(paddings.end(), paddings_vec.begin(), paddings_vec.end()); } diff --git a/mindspore/lite/src/ops/populate/space_to_batch_populate.cc b/mindspore/lite/src/ops/populate/space_to_batch_populate.cc index c9ae8875c8..42e294126d 100644 --- a/mindspore/lite/src/ops/populate/space_to_batch_populate.cc +++ b/mindspore/lite/src/ops/populate/space_to_batch_populate.cc @@ -21,17 +21,26 @@ namespace mindspore { namespace lite { namespace { OpParameter *PopulateSpaceToBatchParameter(const void *prim) { - SpaceToBatchParameter *space_batch_param = - reinterpret_cast(malloc(sizeof(SpaceToBatchParameter))); + auto *space_batch_param = reinterpret_cast(malloc(sizeof(SpaceToBatchParameter))); if (space_batch_param == nullptr) { MS_LOG(ERROR) << "malloc SpaceToBatchParameter failed."; return nullptr; } memset(space_batch_param, 0, sizeof(SpaceToBatchParameter)); - const schema::Primitive *primitive = static_cast(prim); + auto *primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); space_batch_param->op_parameter_.type_ = primitive->value_type(); auto param = primitive->value_as_SpaceToBatch(); - auto block_sizes = std::vector(param->block_size()->begin(), param->block_size()->end()); + if (param == nullptr) { + MS_LOG(ERROR) << "param is nullptr"; + return nullptr; + } + auto block_size = param->block_size(); + if (block_size == nullptr) { + MS_LOG(ERROR) << "block_size is nullptr"; + return nullptr; + } + auto block_sizes = std::vector(block_size->begin(), block_size->end()); if (block_sizes.size() > std::numeric_limits::max() / sizeof(int)) { MS_LOG(ERROR) << "The value of block_sizes.size() is too big"; free(space_batch_param); @@ -39,10 +48,20 @@ OpParameter *PopulateSpaceToBatchParameter(const void *prim) { } space_batch_param->m_ = block_sizes.size(); - auto fb_paddings = param->paddings()->data(); + auto param_paddings = param->paddings(); + if (param_paddings == nullptr) { + MS_LOG(ERROR) << "param_paddings is nullptr"; + return nullptr; + } + auto fb_paddings = param_paddings->data(); + if (fb_paddings == nullptr) { + MS_LOG(ERROR) << "fb_paddings is nullptr"; + return nullptr; + } if (fb_paddings->size() == 0 || - static_cast(fb_paddings->size() * (*(fb_paddings->begin()))->data()->size()) > - std::numeric_limits::max() / sizeof(int64_t)) { + ((*(fb_paddings->begin())) != nullptr && (*(fb_paddings->begin()))->data() != nullptr && + static_cast(fb_paddings->size() * (*(fb_paddings->begin()))->data()->size()) > + std::numeric_limits::max() / sizeof(int64_t))) { MS_LOG(ERROR) << "The value of paddings.size() is zero or too big"; free(space_batch_param); return nullptr; @@ -50,6 +69,10 @@ OpParameter *PopulateSpaceToBatchParameter(const void *prim) { std::vector paddings; for (auto iter = fb_paddings->begin(); iter != fb_paddings->end(); ++iter) { auto paddings_data = (*iter)->data(); + if (paddings_data == nullptr) { + MS_LOG(ERROR) << "paddings_data is nullptr"; + return nullptr; + } auto paddings_vec = std::vector(paddings_data->begin(), paddings_data->end()); paddings.insert(paddings.end(), paddings_vec.begin(), paddings_vec.end()); } diff --git a/mindspore/lite/src/ops/populate/space_to_depth_populate.cc b/mindspore/lite/src/ops/populate/space_to_depth_populate.cc index 270d8fc67e..b673e381d6 100644 --- a/mindspore/lite/src/ops/populate/space_to_depth_populate.cc +++ b/mindspore/lite/src/ops/populate/space_to_depth_populate.cc @@ -20,15 +20,19 @@ using mindspore::schema::PrimitiveType_SpaceToDepth; namespace mindspore { namespace lite { OpParameter *PopulateSpaceToDepthParameter(const void *prim) { - SpaceToDepthParameter *space_depth_param = - reinterpret_cast(malloc(sizeof(SpaceToDepthParameter))); + auto *space_depth_param = reinterpret_cast(malloc(sizeof(SpaceToDepthParameter))); if (space_depth_param == nullptr) { MS_LOG(ERROR) << "malloc SpaceToDepthParameter failed."; return nullptr; } memset(space_depth_param, 0, sizeof(SpaceToDepthParameter)); auto primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); auto value = primitive->value_as_SpaceToDepth(); + if (value == nullptr) { + MS_LOG(ERROR) << "value is nullptr"; + return nullptr; + } space_depth_param->op_parameter_.type_ = primitive->value_type(); space_depth_param->block_size_ = value->block_size(); if (value->format() != schema::Format::Format_NHWC) { diff --git a/mindspore/lite/src/ops/populate/sparse_softmax_cross_entropy_with_logits.cc b/mindspore/lite/src/ops/populate/sparse_softmax_cross_entropy_with_logits.cc index 7a9541202c..6c6ff16fe5 100644 --- a/mindspore/lite/src/ops/populate/sparse_softmax_cross_entropy_with_logits.cc +++ b/mindspore/lite/src/ops/populate/sparse_softmax_cross_entropy_with_logits.cc @@ -20,7 +20,7 @@ using mindspore::schema::PrimitiveType_SparseSoftmaxCrossEntropyWithLogits; namespace mindspore { namespace lite { OpParameter *PopulateSparseSoftmaxCrossEntropyWithLogitsParameter(const void *prim) { - SoftmaxCrossEntropyParameter *softmax_cross_entropy_param_ = + auto *softmax_cross_entropy_param_ = reinterpret_cast(malloc(sizeof(SoftmaxCrossEntropyParameter))); if (softmax_cross_entropy_param_ == nullptr) { MS_LOG(ERROR) << "malloc SoftmaxCrossEntropyParameter failed."; @@ -28,6 +28,7 @@ OpParameter *PopulateSparseSoftmaxCrossEntropyWithLogitsParameter(const void *pr } memset(softmax_cross_entropy_param_, 0, sizeof(SoftmaxCrossEntropyParameter)); auto primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); softmax_cross_entropy_param_->op_parameter_.type_ = primitive->value_type(); return reinterpret_cast(softmax_cross_entropy_param_); } diff --git a/mindspore/lite/src/ops/populate/sparse_to_dense_populate.cc b/mindspore/lite/src/ops/populate/sparse_to_dense_populate.cc index 87fc2b6bd6..45ecb2a92d 100644 --- a/mindspore/lite/src/ops/populate/sparse_to_dense_populate.cc +++ b/mindspore/lite/src/ops/populate/sparse_to_dense_populate.cc @@ -28,6 +28,7 @@ OpParameter *PopulateSparseToDenseParameter(const void *prim) { } memset(sparse_to_dense_param, 0, sizeof(SparseToDenseParameter)); auto primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); sparse_to_dense_param->op_parameter_.type_ = primitive->value_type(); return reinterpret_cast(sparse_to_dense_param); } diff --git a/mindspore/lite/src/ops/populate/splice_populate.cc b/mindspore/lite/src/ops/populate/splice_populate.cc index 6563697864..8e5a618970 100644 --- a/mindspore/lite/src/ops/populate/splice_populate.cc +++ b/mindspore/lite/src/ops/populate/splice_populate.cc @@ -27,10 +27,20 @@ OpParameter *PopulateSpliceParameter(const void *prim) { } memset(splice_parameter, 0, sizeof(SpliceParameter)); auto primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); auto splice_primitive = primitive->value_as_Splice(); + if (splice_primitive == nullptr) { + MS_LOG(ERROR) << "splice_primitive is nullptr"; + return nullptr; + } splice_parameter->op_parameter_.type_ = primitive->value_type(); - std::vector primitive_context(splice_primitive->context()->begin(), splice_primitive->context()->end()); + auto context = splice_primitive->context(); + if (context == nullptr) { + MS_LOG(ERROR) << "context is nullptr"; + return nullptr; + } + std::vector primitive_context(context->begin(), context->end()); splice_parameter->context_dim_ = static_cast(primitive_context.size()); // malloc && memset for context @@ -48,8 +58,12 @@ OpParameter *PopulateSpliceParameter(const void *prim) { src_to_dst_row_offset = std::max(src_to_dst_row_offset, std::abs(primitive_context.at(i))); } - std::vector primitive_forward_indexes(splice_primitive->forward_indexes()->begin(), - splice_primitive->forward_indexes()->end()); + auto forward_indexes = splice_primitive->forward_indexes(); + if (forward_indexes == nullptr) { + MS_LOG(ERROR) << "forward_indexes is nullptr"; + return nullptr; + } + std::vector primitive_forward_indexes(forward_indexes->begin(), forward_indexes->end()); splice_parameter->forward_indexes_dim_ = static_cast(primitive_forward_indexes.size()); // malloc && memset for forward_indexes diff --git a/mindspore/lite/src/ops/populate/split_populate.cc b/mindspore/lite/src/ops/populate/split_populate.cc index 270cbada0e..a855987468 100644 --- a/mindspore/lite/src/ops/populate/split_populate.cc +++ b/mindspore/lite/src/ops/populate/split_populate.cc @@ -29,7 +29,12 @@ OpParameter *PopulateSplitParameter(const void *prim) { memset(split_param, 0, sizeof(SplitParameter)); auto primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); auto value = primitive->value_as_Split(); + if (value == nullptr) { + MS_LOG(ERROR) << "value is nullptr"; + return nullptr; + } split_param->op_parameter_.type_ = primitive->value_type(); split_param->num_split_ = value->output_num(); if (split_param->num_split_ > std::numeric_limits::max() / static_cast(sizeof(int))) { @@ -47,7 +52,7 @@ OpParameter *PopulateSplitParameter(const void *prim) { } memset(split_param->split_sizes_, 0, split_param->num_split_ * sizeof(int)); auto split_sizes_vector_ = value->size_splits(); - if (split_sizes_vector_ != NULL) { + if (split_sizes_vector_ != nullptr) { int i = 0; for (auto iter : *split_sizes_vector_) { split_param->split_sizes_[i++] = iter; diff --git a/mindspore/lite/src/ops/populate/squeeze_populate.cc b/mindspore/lite/src/ops/populate/squeeze_populate.cc index e29dbe39ec..88edfb311b 100644 --- a/mindspore/lite/src/ops/populate/squeeze_populate.cc +++ b/mindspore/lite/src/ops/populate/squeeze_populate.cc @@ -27,14 +27,20 @@ OpParameter *PopulateSqueezeParameter(const void *prim) { return nullptr; } memset(squeeze_param, 0, sizeof(SqueezeParameter)); - const schema::Primitive *primitive = static_cast(prim); + auto *primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); squeeze_param->op_parameter_.type_ = primitive->value_type(); auto squeeze_prim = primitive->value_as_Squeeze(); + if (squeeze_prim == nullptr) { + MS_LOG(ERROR) << "squeeze_prim is nullptr"; + return nullptr; + } + auto axis = squeeze_prim->axis(); if (squeeze_prim->axis() != nullptr) { - squeeze_param->axis_size_ = squeeze_prim->axis()->size(); + squeeze_param->axis_size_ = axis->size(); for (size_t i = 0; i < squeeze_param->axis_size_; i++) { - squeeze_param->axis_[i] = *(squeeze_prim->axis()->begin() + i); + squeeze_param->axis_[i] = *(axis->begin() + i); } } else { squeeze_param->axis_size_ = 0; diff --git a/mindspore/lite/src/ops/populate/stack_populate.cc b/mindspore/lite/src/ops/populate/stack_populate.cc index ca4b375f4b..96876e460d 100644 --- a/mindspore/lite/src/ops/populate/stack_populate.cc +++ b/mindspore/lite/src/ops/populate/stack_populate.cc @@ -21,14 +21,19 @@ namespace mindspore { namespace lite { namespace { OpParameter *PopulateStackParameter(const void *prim) { - StackParameter *stack_param = reinterpret_cast(malloc(sizeof(StackParameter))); + auto *stack_param = reinterpret_cast(malloc(sizeof(StackParameter))); if (stack_param == nullptr) { MS_LOG(ERROR) << "malloc StackParameter failed."; return nullptr; } memset(stack_param, 0, sizeof(StackParameter)); auto primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); auto value = primitive->value_as_Stack(); + if (value == nullptr) { + MS_LOG(ERROR) << "value is nullptr"; + return nullptr; + } stack_param->op_parameter_.type_ = primitive->value_type(); stack_param->axis_ = static_cast(value->axis()); return reinterpret_cast(stack_param); diff --git a/mindspore/lite/src/ops/populate/strided_slice_grad_populate.cc b/mindspore/lite/src/ops/populate/strided_slice_grad_populate.cc index b8e2b534f1..8e2cf7cc4b 100644 --- a/mindspore/lite/src/ops/populate/strided_slice_grad_populate.cc +++ b/mindspore/lite/src/ops/populate/strided_slice_grad_populate.cc @@ -28,7 +28,12 @@ OpParameter *PopulateStridedSliceGradParameter(const void *prim) { memset(strided_slice_param, 0, sizeof(StridedSliceParameter)); auto primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); auto value = primitive->value_as_StridedSliceGrad(); + if (value == nullptr) { + MS_LOG(ERROR) << "value is nullptr"; + return nullptr; + } strided_slice_param->op_parameter_.type_ = primitive->value_type(); strided_slice_param->begins_mask_ = value->begin_mask(); diff --git a/mindspore/lite/src/ops/populate/strided_slice_populate.cc b/mindspore/lite/src/ops/populate/strided_slice_populate.cc index 32087bd4d1..0ebb36fcc0 100644 --- a/mindspore/lite/src/ops/populate/strided_slice_populate.cc +++ b/mindspore/lite/src/ops/populate/strided_slice_populate.cc @@ -19,8 +19,7 @@ using mindspore::schema::PrimitiveType_StridedSlice; namespace mindspore { namespace lite { OpParameter *PopulateStridedSliceParameter(const void *prim) { - StridedSliceParameter *strided_slice_param = - reinterpret_cast(malloc(sizeof(StridedSliceParameter))); + auto *strided_slice_param = reinterpret_cast(malloc(sizeof(StridedSliceParameter))); if (strided_slice_param == nullptr) { MS_LOG(ERROR) << "malloc StridedSliceParameter failed."; return nullptr; @@ -28,7 +27,12 @@ OpParameter *PopulateStridedSliceParameter(const void *prim) { memset(strided_slice_param, 0, sizeof(StridedSliceParameter)); auto primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); auto value = primitive->value_as_StridedSlice(); + if (value == nullptr) { + MS_LOG(ERROR) << "value is nullptr"; + return nullptr; + } strided_slice_param->op_parameter_.type_ = primitive->value_type(); strided_slice_param->begins_mask_ = value->begin_mask(); diff --git a/mindspore/lite/src/ops/populate/sub_populate.cc b/mindspore/lite/src/ops/populate/sub_populate.cc index 0ce901da18..92e9ef3c69 100644 --- a/mindspore/lite/src/ops/populate/sub_populate.cc +++ b/mindspore/lite/src/ops/populate/sub_populate.cc @@ -20,7 +20,6 @@ using mindspore::schema::PrimitiveType_SubFusion; namespace mindspore { namespace lite { - OpParameter *PopulateSubParameter(const void *prim) { ArithmeticParameter *param = PopulateArithmeticCommonPara(prim); if (param == nullptr) { @@ -28,6 +27,7 @@ OpParameter *PopulateSubParameter(const void *prim) { return nullptr; } auto primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); param->op_parameter_.type_ = primitive->value_type(); return reinterpret_cast(param); } diff --git a/mindspore/lite/src/ops/populate/switch_populate.cc b/mindspore/lite/src/ops/populate/switch_populate.cc index 4859470fbd..c3ba0208ed 100644 --- a/mindspore/lite/src/ops/populate/switch_populate.cc +++ b/mindspore/lite/src/ops/populate/switch_populate.cc @@ -19,13 +19,14 @@ using mindspore::schema::PrimitiveType_Switch; namespace mindspore { namespace lite { OpParameter *PopulateSwitchParameter(const void *prim) { - OpParameter *switch_parameter = reinterpret_cast(malloc(sizeof(OpParameter))); + auto *switch_parameter = reinterpret_cast(malloc(sizeof(OpParameter))); if (switch_parameter == nullptr) { MS_LOG(ERROR) << "malloc SwitchParameter failed."; return nullptr; } memset(switch_parameter, 0, sizeof(OpParameter)); auto primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); switch_parameter->type_ = primitive->value_type(); return reinterpret_cast(switch_parameter); diff --git a/mindspore/lite/src/ops/populate/tensorlistfromtensor_populate.cc b/mindspore/lite/src/ops/populate/tensorlistfromtensor_populate.cc index d88f504d01..ccbf5cdfa9 100644 --- a/mindspore/lite/src/ops/populate/tensorlistfromtensor_populate.cc +++ b/mindspore/lite/src/ops/populate/tensorlistfromtensor_populate.cc @@ -21,14 +21,19 @@ using mindspore::schema::PrimitiveType_TensorListFromTensor; namespace mindspore { namespace lite { OpParameter *PopulateTensorListFromTensorParameter(const void *prim) { - TensorListParameter *TensorList_param = reinterpret_cast(malloc(sizeof(TensorListParameter))); + auto *TensorList_param = reinterpret_cast(malloc(sizeof(TensorListParameter))); if (TensorList_param == nullptr) { MS_LOG(ERROR) << "malloc TensorListParameter failed."; return nullptr; } memset(TensorList_param, 0, sizeof(TensorListParameter)); auto primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); auto value = primitive->value_as_TensorListFromTensor(); + if (value == nullptr) { + MS_LOG(ERROR) << "value is nullptr"; + return nullptr; + } TensorList_param->op_parameter_.type_ = primitive->value_type(); TensorList_param->shape_type_ = value->shape_type(); TensorList_param->element_dtype_ = value->element_dtype(); diff --git a/mindspore/lite/src/ops/populate/tensorlistgetitem_populate.cc b/mindspore/lite/src/ops/populate/tensorlistgetitem_populate.cc index a30fb5c3c2..fcbb4646ba 100644 --- a/mindspore/lite/src/ops/populate/tensorlistgetitem_populate.cc +++ b/mindspore/lite/src/ops/populate/tensorlistgetitem_populate.cc @@ -20,14 +20,19 @@ using mindspore::schema::PrimitiveType_TensorListGetItem; namespace mindspore { namespace lite { OpParameter *PopulateTensorListGetItemParameter(const void *prim) { - TensorListParameter *getItem_param = reinterpret_cast(malloc(sizeof(TensorListParameter))); + auto *getItem_param = reinterpret_cast(malloc(sizeof(TensorListParameter))); if (getItem_param == nullptr) { MS_LOG(ERROR) << "malloc TensorListParameter failed."; return nullptr; } memset(getItem_param, 0, sizeof(TensorListParameter)); auto primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); auto value = primitive->value_as_TensorListGetItem(); + if (value == nullptr) { + MS_LOG(ERROR) << "value is nullptr"; + return nullptr; + } getItem_param->op_parameter_.type_ = primitive->value_type(); getItem_param->element_dtype_ = value->element_dtype(); return reinterpret_cast(getItem_param); diff --git a/mindspore/lite/src/ops/populate/tensorlistreserve_populate.cc b/mindspore/lite/src/ops/populate/tensorlistreserve_populate.cc index 0e5cba5e5e..e0d9244e7f 100644 --- a/mindspore/lite/src/ops/populate/tensorlistreserve_populate.cc +++ b/mindspore/lite/src/ops/populate/tensorlistreserve_populate.cc @@ -20,14 +20,19 @@ using mindspore::schema::PrimitiveType_TensorListReserve; namespace mindspore { namespace lite { OpParameter *PopulateTensorListReserveParameter(const void *prim) { - TensorListParameter *reserve_param = reinterpret_cast(malloc(sizeof(TensorListParameter))); + auto *reserve_param = reinterpret_cast(malloc(sizeof(TensorListParameter))); if (reserve_param == nullptr) { MS_LOG(ERROR) << "malloc TensorListParameter failed."; return nullptr; } memset(reserve_param, 0, sizeof(TensorListParameter)); auto primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); auto value = primitive->value_as_TensorListReserve(); + if (value == nullptr) { + MS_LOG(ERROR) << "value is nullptr"; + return nullptr; + } reserve_param->op_parameter_.type_ = primitive->value_type(); reserve_param->element_dtype_ = value->element_dtype(); return reinterpret_cast(reserve_param); diff --git a/mindspore/lite/src/ops/populate/tensorlistsetlitem_populate.cc b/mindspore/lite/src/ops/populate/tensorlistsetlitem_populate.cc index 9ca3169a4f..d14f32ab1a 100644 --- a/mindspore/lite/src/ops/populate/tensorlistsetlitem_populate.cc +++ b/mindspore/lite/src/ops/populate/tensorlistsetlitem_populate.cc @@ -20,14 +20,19 @@ using mindspore::schema::PrimitiveType_TensorListSetItem; namespace mindspore { namespace lite { OpParameter *PopulateTensorListSetItemParameter(const void *prim) { - TensorListParameter *setItem_param = reinterpret_cast(malloc(sizeof(TensorListParameter))); + auto *setItem_param = reinterpret_cast(malloc(sizeof(TensorListParameter))); if (setItem_param == nullptr) { MS_LOG(ERROR) << "malloc TensorListParameter failed."; return nullptr; } memset(setItem_param, 0, sizeof(TensorListParameter)); auto primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); auto value = primitive->value_as_TensorListSetItem(); + if (value == nullptr) { + MS_LOG(ERROR) << "value is nullptr"; + return nullptr; + } setItem_param->op_parameter_.type_ = primitive->value_type(); setItem_param->element_dtype_ = value->element_dtype(); return reinterpret_cast(setItem_param); diff --git a/mindspore/lite/src/ops/populate/tensorliststack_populate.cc b/mindspore/lite/src/ops/populate/tensorliststack_populate.cc index f955099630..6eda2200c4 100644 --- a/mindspore/lite/src/ops/populate/tensorliststack_populate.cc +++ b/mindspore/lite/src/ops/populate/tensorliststack_populate.cc @@ -20,14 +20,19 @@ using mindspore::schema::PrimitiveType_TensorListStack; namespace mindspore { namespace lite { OpParameter *PopulateTensorListStackParameter(const void *prim) { - TensorListParameter *stack_param = reinterpret_cast(malloc(sizeof(TensorListParameter))); + auto *stack_param = reinterpret_cast(malloc(sizeof(TensorListParameter))); if (stack_param == nullptr) { MS_LOG(ERROR) << "malloc TensorListParameter failed."; return nullptr; } memset(stack_param, 0, sizeof(TensorListParameter)); auto primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); auto value = primitive->value_as_TensorListStack(); + if (value == nullptr) { + MS_LOG(ERROR) << "value is nullptr"; + return nullptr; + } stack_param->op_parameter_.type_ = primitive->value_type(); stack_param->element_dtype_ = value->element_dtype(); stack_param->num_element_ = value->num_elements(); diff --git a/mindspore/lite/src/ops/populate/tile_populate.cc b/mindspore/lite/src/ops/populate/tile_populate.cc index 66bfee8ca4..a78f57252d 100644 --- a/mindspore/lite/src/ops/populate/tile_populate.cc +++ b/mindspore/lite/src/ops/populate/tile_populate.cc @@ -19,16 +19,20 @@ using mindspore::schema::PrimitiveType_TileFusion; namespace mindspore { namespace lite { - OpParameter *PopulateTileParameter(const void *prim) { - TileParameter *tile_param = reinterpret_cast(malloc(sizeof(TileParameter))); + auto *tile_param = reinterpret_cast(malloc(sizeof(TileParameter))); if (tile_param == nullptr) { MS_LOG(ERROR) << "malloc TileParameter failed."; return nullptr; } memset(tile_param, 0, sizeof(TileParameter)); auto primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); auto value = primitive->value_as_TileFusion(); + if (value == nullptr) { + MS_LOG(ERROR) << "value is nullptr"; + return nullptr; + } tile_param->op_parameter_.type_ = primitive->value_type(); auto dims = value->dims(); if (dims != nullptr) { diff --git a/mindspore/lite/src/ops/populate/topk_populate.cc b/mindspore/lite/src/ops/populate/topk_populate.cc index e2dc4a0ee2..d75b685c41 100644 --- a/mindspore/lite/src/ops/populate/topk_populate.cc +++ b/mindspore/lite/src/ops/populate/topk_populate.cc @@ -21,15 +21,20 @@ namespace mindspore { namespace lite { namespace { OpParameter *PopulateTopKParameter(const void *prim) { - TopkParameter *topk_param = reinterpret_cast(malloc(sizeof(TopkParameter))); + auto *topk_param = reinterpret_cast(malloc(sizeof(TopkParameter))); if (topk_param == nullptr) { MS_LOG(ERROR) << "malloc TopkParameter failed."; return nullptr; } memset(topk_param, 0, sizeof(TopkParameter)); auto primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); topk_param->op_parameter_.type_ = primitive->value_type(); auto param = primitive->value_as_TopKFusion(); + if (param == nullptr) { + MS_LOG(ERROR) << "param is nullptr"; + return nullptr; + } topk_param->sorted_ = param->sorted(); return reinterpret_cast(topk_param); } diff --git a/mindspore/lite/src/ops/populate/transpose_populate.cc b/mindspore/lite/src/ops/populate/transpose_populate.cc index 53aa90ecca..5441599f57 100644 --- a/mindspore/lite/src/ops/populate/transpose_populate.cc +++ b/mindspore/lite/src/ops/populate/transpose_populate.cc @@ -21,13 +21,14 @@ namespace mindspore { namespace lite { namespace { OpParameter *PopulateTransposeParameter(const void *prim) { - TransposeParameter *transpose_param = reinterpret_cast(malloc(sizeof(TransposeParameter))); + auto *transpose_param = reinterpret_cast(malloc(sizeof(TransposeParameter))); if (transpose_param == nullptr) { MS_LOG(ERROR) << "malloc TransposeParameter failed."; return nullptr; } memset(transpose_param, 0, sizeof(TransposeParameter)); auto primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); transpose_param->op_parameter_.type_ = primitive->value_type(); return reinterpret_cast(transpose_param); } diff --git a/mindspore/lite/src/ops/populate/uniform_real_populate.cc b/mindspore/lite/src/ops/populate/uniform_real_populate.cc index c3123106b0..d2731375b0 100644 --- a/mindspore/lite/src/ops/populate/uniform_real_populate.cc +++ b/mindspore/lite/src/ops/populate/uniform_real_populate.cc @@ -28,8 +28,13 @@ OpParameter *PopulateRandomStandardNormalParameter(const void *prim) { } memset(random_parameter, 0, sizeof(RandomParam)); auto *primitive = static_cast(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(random_parameter); diff --git a/mindspore/lite/src/ops/populate/unique_populate.cc b/mindspore/lite/src/ops/populate/unique_populate.cc index a5ae402a31..d9c332a463 100644 --- a/mindspore/lite/src/ops/populate/unique_populate.cc +++ b/mindspore/lite/src/ops/populate/unique_populate.cc @@ -21,13 +21,14 @@ namespace mindspore { namespace lite { namespace { OpParameter *PopulateUniqueParameter(const void *prim) { - UniqueParameter *unique_param = reinterpret_cast(malloc(sizeof(UniqueParameter))); + auto *unique_param = reinterpret_cast(malloc(sizeof(UniqueParameter))); if (unique_param == nullptr) { MS_LOG(ERROR) << "malloc UniqueParameter failed."; return nullptr; } memset(unique_param, 0, sizeof(UniqueParameter)); auto primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); unique_param->op_parameter_.type_ = primitive->value_type(); return reinterpret_cast(unique_param); } diff --git a/mindspore/lite/src/ops/populate/unsorted_segment_sum_populate.cc b/mindspore/lite/src/ops/populate/unsorted_segment_sum_populate.cc index fdec1f31d0..6e71e7e442 100644 --- a/mindspore/lite/src/ops/populate/unsorted_segment_sum_populate.cc +++ b/mindspore/lite/src/ops/populate/unsorted_segment_sum_populate.cc @@ -19,13 +19,14 @@ using mindspore::schema::PrimitiveType_UnsortedSegmentSum; namespace mindspore { namespace lite { OpParameter *PopulateUnsortedSegmentSumParameter(const void *prim) { - OpParameter *param = reinterpret_cast(malloc(sizeof(OpParameter))); + auto *param = reinterpret_cast(malloc(sizeof(OpParameter))); if (param == nullptr) { MS_LOG(ERROR) << "malloc UnsortedSegmentSum Parameter failed."; return nullptr; } memset(param, 0, sizeof(OpParameter)); auto primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); param->type_ = primitive->value_type(); return param; } diff --git a/mindspore/lite/src/ops/populate/unsqueeze_populate.cc b/mindspore/lite/src/ops/populate/unsqueeze_populate.cc index ea256a221e..fab41680cb 100644 --- a/mindspore/lite/src/ops/populate/unsqueeze_populate.cc +++ b/mindspore/lite/src/ops/populate/unsqueeze_populate.cc @@ -21,16 +21,26 @@ namespace mindspore { namespace lite { namespace { OpParameter *PopulateUnsqueezeParameter(const void *prim) { - UnSqueezeParameter *unsqueeze_param = reinterpret_cast(malloc(sizeof(UnSqueezeParameter))); + auto *unsqueeze_param = reinterpret_cast(malloc(sizeof(UnSqueezeParameter))); if (unsqueeze_param == nullptr) { MS_LOG(ERROR) << "malloc UnSqueezeParameter failed."; return nullptr; } memset(unsqueeze_param, 0, sizeof(UnSqueezeParameter)); auto primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); unsqueeze_param->op_parameter_.type_ = primitive->value_type(); auto unsqueeze_prim = primitive->value_as_Unsqueeze(); - auto flat_axis = std::vector(unsqueeze_prim->axis()->begin(), unsqueeze_prim->axis()->end()); + if (unsqueeze_prim == nullptr) { + MS_LOG(ERROR) << "unsqueeze_prim is nullptr"; + return nullptr; + } + auto axis = unsqueeze_prim->axis(); + if (axis == nullptr) { + MS_LOG(ERROR) << "axis is nullptr"; + return nullptr; + } + auto flat_axis = std::vector(axis->begin(), axis->end()); unsqueeze_param->num_dim_ = flat_axis.size(); int i = 0; for (auto iter = flat_axis.begin(); iter != flat_axis.end(); ++iter) { diff --git a/mindspore/lite/src/ops/populate/unstack_populate.cc b/mindspore/lite/src/ops/populate/unstack_populate.cc index 1109697fc2..b47ef73b9c 100644 --- a/mindspore/lite/src/ops/populate/unstack_populate.cc +++ b/mindspore/lite/src/ops/populate/unstack_populate.cc @@ -21,14 +21,19 @@ namespace mindspore { namespace lite { OpParameter *PopulateUnstackParameter(const void *prim) { - UnstackParameter *unstack_param = reinterpret_cast(malloc(sizeof(UnstackParameter))); + auto *unstack_param = reinterpret_cast(malloc(sizeof(UnstackParameter))); if (unstack_param == nullptr) { MS_LOG(ERROR) << "malloc UnstackParameter failed."; return nullptr; } memset(unstack_param, 0, sizeof(UnstackParameter)); auto primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); auto value = primitive->value_as_Unstack(); + if (value == nullptr) { + MS_LOG(ERROR) << "value is nullptr"; + return nullptr; + } unstack_param->op_parameter_.type_ = primitive->value_type(); unstack_param->axis_ = value->axis(); return reinterpret_cast(unstack_param); diff --git a/mindspore/lite/src/ops/populate/v0/activation_grad_populate_v0.cc b/mindspore/lite/src/ops/populate/v0/activation_grad_populate_v0.cc index 0e06a24f48..8daba13841 100644 --- a/mindspore/lite/src/ops/populate/v0/activation_grad_populate_v0.cc +++ b/mindspore/lite/src/ops/populate/v0/activation_grad_populate_v0.cc @@ -23,9 +23,13 @@ namespace lite { namespace { OpParameter *PopulateActivationGradParameter(const void *prim) { auto *primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); auto activation_grad_prim = primitive->value_as_ActivationGrad(); - ActivationGradParameter *act_param = - reinterpret_cast(malloc(sizeof(ActivationGradParameter))); + if (activation_grad_prim == nullptr) { + MS_LOG(ERROR) << "activation_grad_prim is nullptr"; + return nullptr; + } + auto *act_param = reinterpret_cast(malloc(sizeof(ActivationGradParameter))); if (act_param == nullptr) { MS_LOG(ERROR) << "malloc ActivationParameter failed."; return nullptr; diff --git a/mindspore/lite/src/ops/populate/v0/activation_populate_v0.cc b/mindspore/lite/src/ops/populate/v0/activation_populate_v0.cc index a08c3d9c0c..4da055487d 100644 --- a/mindspore/lite/src/ops/populate/v0/activation_populate_v0.cc +++ b/mindspore/lite/src/ops/populate/v0/activation_populate_v0.cc @@ -23,8 +23,13 @@ namespace lite { namespace { OpParameter *PopulateActivationParameter(const void *prim) { auto *primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); auto activation_prim = primitive->value_as_Activation(); - ActivationParameter *act_param = reinterpret_cast(malloc(sizeof(ActivationParameter))); + if (activation_prim == nullptr) { + MS_LOG(ERROR) << "activation_prim is nullptr"; + return nullptr; + } + auto *act_param = reinterpret_cast(malloc(sizeof(ActivationParameter))); if (act_param == nullptr) { MS_LOG(ERROR) << "malloc ActivationParameter failed."; return nullptr; diff --git a/mindspore/lite/src/ops/populate/v0/add_populate_v0.cc b/mindspore/lite/src/ops/populate/v0/add_populate_v0.cc index 9f80d6ca1d..37fa84de1f 100644 --- a/mindspore/lite/src/ops/populate/v0/add_populate_v0.cc +++ b/mindspore/lite/src/ops/populate/v0/add_populate_v0.cc @@ -24,8 +24,13 @@ namespace lite { namespace { OpParameter *PopulateAddParameter(const void *prim) { auto *primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); auto add_prim = primitive->value_as_Add(); - ArithmeticParameter *param = PopulateArithmeticV0CommonPara(primitive); + if (add_prim == nullptr) { + MS_LOG(ERROR) << "add_prim is nullptr"; + return nullptr; + } + auto *param = PopulateArithmeticV0CommonPara(primitive); if (param == nullptr) { MS_LOG(ERROR) << "PopulateArithmeticCommonPara failed."; return nullptr; diff --git a/mindspore/lite/src/ops/populate/v0/argmax_populate_v0.cc b/mindspore/lite/src/ops/populate/v0/argmax_populate_v0.cc index 0e1682d865..05deb3ad01 100644 --- a/mindspore/lite/src/ops/populate/v0/argmax_populate_v0.cc +++ b/mindspore/lite/src/ops/populate/v0/argmax_populate_v0.cc @@ -23,8 +23,13 @@ namespace lite { namespace { OpParameter *PopulateArgMaxParameter(const void *prim) { auto *primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); auto argmax_prim = primitive->value_as_ArgMax(); - ArgMinMaxParameter *arg_param = reinterpret_cast(malloc(sizeof(ArgMinMaxParameter))); + if (argmax_prim == nullptr) { + MS_LOG(ERROR) << "argmax_prim is nullptr"; + return nullptr; + } + auto *arg_param = reinterpret_cast(malloc(sizeof(ArgMinMaxParameter))); if (arg_param == nullptr) { MS_LOG(ERROR) << "malloc ArgMinMaxParameter failed."; return nullptr; diff --git a/mindspore/lite/src/ops/populate/v0/argmin_populate_v0.cc b/mindspore/lite/src/ops/populate/v0/argmin_populate_v0.cc index 10d82fa59f..bba3780d4d 100644 --- a/mindspore/lite/src/ops/populate/v0/argmin_populate_v0.cc +++ b/mindspore/lite/src/ops/populate/v0/argmin_populate_v0.cc @@ -23,8 +23,13 @@ namespace lite { namespace { OpParameter *PopulateArgMinParameter(const void *prim) { auto *primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); auto argmin_prim = primitive->value_as_ArgMin(); - ArgMinMaxParameter *arg_param = reinterpret_cast(malloc(sizeof(ArgMinMaxParameter))); + if (argmin_prim == nullptr) { + MS_LOG(ERROR) << "argmin_prim is nullptr"; + return nullptr; + } + auto *arg_param = reinterpret_cast(malloc(sizeof(ArgMinMaxParameter))); if (arg_param == nullptr) { MS_LOG(ERROR) << "malloc ArgMinMaxParameter failed."; return nullptr; diff --git a/mindspore/lite/src/ops/populate/v0/arithmetic_populate_v0.cc b/mindspore/lite/src/ops/populate/v0/arithmetic_populate_v0.cc index 8454e57a75..77d8b308a6 100644 --- a/mindspore/lite/src/ops/populate/v0/arithmetic_populate_v0.cc +++ b/mindspore/lite/src/ops/populate/v0/arithmetic_populate_v0.cc @@ -23,13 +23,14 @@ namespace mindspore { namespace lite { ArithmeticParameter *PopulateArithmeticV0CommonPara(const void *prim) { + auto *primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); auto *param = reinterpret_cast(malloc(sizeof(ArithmeticParameter))); if (param == nullptr) { MS_LOG(ERROR) << "malloc ArithmeticParameter failed."; return nullptr; } memset(param, 0, sizeof(ArithmeticParameter)); - const auto *primitive = static_cast(prim); param->op_parameter_.type_ = primitive->value_type(); param->broadcasting_ = false; param->ndim_ = 0; @@ -38,7 +39,7 @@ ArithmeticParameter *PopulateArithmeticV0CommonPara(const void *prim) { } OpParameter *PopulateArithmeticV0(const void *primitive) { - ArithmeticParameter *param = PopulateArithmeticV0CommonPara(primitive); + auto *param = PopulateArithmeticV0CommonPara(primitive); if (param == nullptr) { MS_LOG(ERROR) << "PopulateArithmeticCommonPara failed."; return nullptr; diff --git a/mindspore/lite/src/ops/populate/v0/arithmetic_self_populate_v0.cc b/mindspore/lite/src/ops/populate/v0/arithmetic_self_populate_v0.cc index 5e497faf61..2acdb19e21 100644 --- a/mindspore/lite/src/ops/populate/v0/arithmetic_self_populate_v0.cc +++ b/mindspore/lite/src/ops/populate/v0/arithmetic_self_populate_v0.cc @@ -23,14 +23,14 @@ namespace mindspore { namespace lite { namespace { OpParameter *PopulateArithmeticSelfV0(const void *prim) { - ArithmeticSelfParameter *arithmetic_self_param = - reinterpret_cast(malloc(sizeof(ArithmeticSelfParameter))); + auto *primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); + auto *arithmetic_self_param = reinterpret_cast(malloc(sizeof(ArithmeticSelfParameter))); if (arithmetic_self_param == nullptr) { MS_LOG(ERROR) << "malloc ArithmeticSelfParameter failed."; return nullptr; } memset(arithmetic_self_param, 0, sizeof(ArithmeticSelfParameter)); - auto primitive = static_cast(prim); int type = primitive->value_type(); if (type == schema::v0::PrimitiveType_Abs) { arithmetic_self_param->op_parameter_.type_ = schema::PrimitiveType_Abs; diff --git a/mindspore/lite/src/ops/populate/v0/batch_norm_populate_v0.cc b/mindspore/lite/src/ops/populate/v0/batch_norm_populate_v0.cc index 71dee7f1ce..d1c613cb89 100644 --- a/mindspore/lite/src/ops/populate/v0/batch_norm_populate_v0.cc +++ b/mindspore/lite/src/ops/populate/v0/batch_norm_populate_v0.cc @@ -23,9 +23,13 @@ namespace lite { namespace { OpParameter *PopulateBatchNormParameter(const void *prim) { auto *primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); auto batch_norm_prim = primitive->value_as_BatchNorm(); - - BatchNormParameter *batch_norm_param = reinterpret_cast(malloc(sizeof(BatchNormParameter))); + if (batch_norm_prim == nullptr) { + MS_LOG(ERROR) << "batch_norm_prim is nullptr"; + return nullptr; + } + auto *batch_norm_param = reinterpret_cast(malloc(sizeof(BatchNormParameter))); if (batch_norm_param == nullptr) { MS_LOG(ERROR) << "malloc BatchNormParameter failed."; return nullptr; diff --git a/mindspore/lite/src/ops/populate/v0/batch_to_space_populate_v0.cc b/mindspore/lite/src/ops/populate/v0/batch_to_space_populate_v0.cc index a8ff816a90..30b803c6f3 100644 --- a/mindspore/lite/src/ops/populate/v0/batch_to_space_populate_v0.cc +++ b/mindspore/lite/src/ops/populate/v0/batch_to_space_populate_v0.cc @@ -23,9 +23,13 @@ namespace lite { namespace { OpParameter *PopulateBatchToSpaceParameter(const void *prim) { auto *primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); auto batch_to_space_prim = primitive->value_as_BatchToSpace(); - BatchToSpaceParameter *batch_space_param = - reinterpret_cast(malloc(sizeof(BatchToSpaceParameter))); + if (batch_to_space_prim == nullptr) { + MS_LOG(ERROR) << "batch_to_space_prim is nullptr"; + return nullptr; + } + auto *batch_space_param = reinterpret_cast(malloc(sizeof(BatchToSpaceParameter))); if (batch_space_param == nullptr) { MS_LOG(ERROR) << "malloc BatchToSpaceParameter failed."; return nullptr; @@ -38,6 +42,10 @@ OpParameter *PopulateBatchToSpaceParameter(const void *prim) { } auto block_shape = batch_to_space_prim->blockShape(); + if (block_shape == nullptr) { + MS_LOG(ERROR) << "block_shape is nullptr"; + return nullptr; + } 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); @@ -45,6 +53,10 @@ OpParameter *PopulateBatchToSpaceParameter(const void *prim) { } auto crops = batch_to_space_prim->crops(); + if (crops == nullptr) { + MS_LOG(ERROR) << "crops is nullptr"; + return nullptr; + } if (crops->size() != COMM_SHAPE_SIZE) { MS_LOG(ERROR) << "batch_to_space crops size should be " << COMM_SHAPE_SIZE; free(batch_space_param); diff --git a/mindspore/lite/src/ops/populate/v0/binary_cross_entropy_grad_populate_v0.cc b/mindspore/lite/src/ops/populate/v0/binary_cross_entropy_grad_populate_v0.cc index 9dadf89add..9beb207c54 100644 --- a/mindspore/lite/src/ops/populate/v0/binary_cross_entropy_grad_populate_v0.cc +++ b/mindspore/lite/src/ops/populate/v0/binary_cross_entropy_grad_populate_v0.cc @@ -23,8 +23,13 @@ namespace lite { namespace { OpParameter *PopulateBinaryCrossEntropyGradParameter(const void *prim) { auto *primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); auto binary_cross_entropy_grad_prim = primitive->value_as_BinaryCrossEntropyGrad(); - BinaryCrossEntropyGradParameter *bce_param = + if (binary_cross_entropy_grad_prim == nullptr) { + MS_LOG(ERROR) << "binary_cross_entropy_grad_prim is nullptr"; + return nullptr; + } + auto *bce_param = reinterpret_cast(malloc(sizeof(BinaryCrossEntropyGradParameter))); if (bce_param == nullptr) { MS_LOG(ERROR) << "malloc BinaryCrossEntropyGrad Parameter failed."; diff --git a/mindspore/lite/src/ops/populate/v0/binary_cross_entropy_populate_v0.cc b/mindspore/lite/src/ops/populate/v0/binary_cross_entropy_populate_v0.cc index 2f58d24cad..676b38698a 100644 --- a/mindspore/lite/src/ops/populate/v0/binary_cross_entropy_populate_v0.cc +++ b/mindspore/lite/src/ops/populate/v0/binary_cross_entropy_populate_v0.cc @@ -23,9 +23,13 @@ namespace lite { namespace { OpParameter *PopulateBinaryCrossEntropyParameter(const void *prim) { auto *primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); auto binary_cross_entropy_prim = primitive->value_as_BinaryCrossEntropy(); - BinaryCrossEntropyParameter *bce_param = - reinterpret_cast(malloc(sizeof(BinaryCrossEntropyParameter))); + if (binary_cross_entropy_prim == nullptr) { + MS_LOG(ERROR) << "binary_cross_entropy_prim is nullptr"; + return nullptr; + } + auto *bce_param = reinterpret_cast(malloc(sizeof(BinaryCrossEntropyParameter))); if (bce_param == nullptr) { MS_LOG(ERROR) << "malloc BinaryCrossEntropy Parameter failed."; return nullptr; diff --git a/mindspore/lite/src/ops/populate/v0/broadcast_to_populate_v0.cc b/mindspore/lite/src/ops/populate/v0/broadcast_to_populate_v0.cc index fa78b3af3d..fba6931876 100644 --- a/mindspore/lite/src/ops/populate/v0/broadcast_to_populate_v0.cc +++ b/mindspore/lite/src/ops/populate/v0/broadcast_to_populate_v0.cc @@ -23,9 +23,13 @@ namespace lite { namespace { OpParameter *PopulateBroadcastToParameter(const void *prim) { auto *primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); auto broadcast_to_prim = primitive->value_as_BroadcastTo(); - BroadcastToParameter *broadcast_param = - reinterpret_cast(malloc(sizeof(BroadcastToParameter))); + if (broadcast_to_prim == nullptr) { + MS_LOG(ERROR) << "broadcast_to_prim is nullptr"; + return nullptr; + } + auto *broadcast_param = reinterpret_cast(malloc(sizeof(BroadcastToParameter))); if (broadcast_param == nullptr) { MS_LOG(ERROR) << "malloc BroadcastToParameter failed."; return nullptr; @@ -34,6 +38,10 @@ OpParameter *PopulateBroadcastToParameter(const void *prim) { broadcast_param->op_parameter_.type_ = schema::PrimitiveType_BroadcastTo; auto dst_shape = broadcast_to_prim->dst_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->begin() + i); diff --git a/mindspore/lite/src/ops/populate/v0/common_populate_v0.cc b/mindspore/lite/src/ops/populate/v0/common_populate_v0.cc index c8792e143f..1aea7aa26e 100644 --- a/mindspore/lite/src/ops/populate/v0/common_populate_v0.cc +++ b/mindspore/lite/src/ops/populate/v0/common_populate_v0.cc @@ -27,7 +27,9 @@ OpParameter *PopulateCommonParameter(const void *prim) { return nullptr; } memset(common_parameter, 0, sizeof(OpParameter)); - auto type = reinterpret_cast(prim)->value_type(); + auto *primitive = reinterpret_cast(prim); + MS_ASSERT(primitive != nullptr); + auto type = primitive->value_type(); if (type == schema::v0::PrimitiveType_ZerosLike) { common_parameter->type_ = schema::PrimitiveType_ZerosLike; } else { diff --git a/mindspore/lite/src/ops/populate/v0/concat_populate_v0.cc b/mindspore/lite/src/ops/populate/v0/concat_populate_v0.cc index 76e362de84..13203e8c24 100644 --- a/mindspore/lite/src/ops/populate/v0/concat_populate_v0.cc +++ b/mindspore/lite/src/ops/populate/v0/concat_populate_v0.cc @@ -23,8 +23,13 @@ namespace lite { namespace { OpParameter *PopulateConcatParameter(const void *prim) { auto *primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); auto concat_prim = primitive->value_as_Concat(); - ConcatParameter *concat_param = reinterpret_cast(malloc(sizeof(ConcatParameter))); + if (concat_prim == nullptr) { + MS_LOG(ERROR) << "concat_prim is nullptr"; + return nullptr; + } + auto *concat_param = reinterpret_cast(malloc(sizeof(ConcatParameter))); if (concat_param == nullptr) { MS_LOG(ERROR) << "malloc ConcatParameter failed."; return nullptr; diff --git a/mindspore/lite/src/ops/populate/v0/constant_of_shape_populate_v0.cc b/mindspore/lite/src/ops/populate/v0/constant_of_shape_populate_v0.cc index cb40ba5be2..20ff726222 100644 --- a/mindspore/lite/src/ops/populate/v0/constant_of_shape_populate_v0.cc +++ b/mindspore/lite/src/ops/populate/v0/constant_of_shape_populate_v0.cc @@ -22,10 +22,13 @@ namespace mindspore::lite { namespace { OpParameter *PopulateConstantOfShapeParameter(const void *prim) { auto *primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); auto constant_of_shape_prim = primitive->value_as_ConstantOfShape(); - - ConstantOfShapeParameter *param = - reinterpret_cast(malloc(sizeof(ConstantOfShapeParameter))); + if (constant_of_shape_prim == nullptr) { + MS_LOG(ERROR) << "constant_of_shape_prim is nullptr"; + return nullptr; + } + auto *param = reinterpret_cast(malloc(sizeof(ConstantOfShapeParameter))); if (param == nullptr) { MS_LOG(ERROR) << "malloc ConstantOfShapeParameter failed."; return nullptr; @@ -37,12 +40,17 @@ OpParameter *PopulateConstantOfShapeParameter(const void *prim) { if (value->size() == 0 || value->size() > 1) { MS_LOG(ERROR) << "The value of constant of shape is empty or more than 1."; } else { + auto val = constant_of_shape_prim->value(); + if (val == nullptr) { + MS_LOG(ERROR) << "val is nullptr"; + return nullptr; + } switch (param->data_type_) { case kNumberTypeFloat32: - param->value_.f32_value_ = constant_of_shape_prim->value()->data()[0]; + param->value_.f32_value_ = val->data()[0]; break; case kNumberTypeInt32: - param->value_.int32_value_ = constant_of_shape_prim->value()->data()[0]; + param->value_.int32_value_ = val->data()[0]; break; default: MS_LOG(ERROR) << "The value of constant of shape is invalid"; diff --git a/mindspore/lite/src/ops/populate/v0/conv2d_populate_v0.cc b/mindspore/lite/src/ops/populate/v0/conv2d_populate_v0.cc index fa4292e79b..115bae3bcf 100644 --- a/mindspore/lite/src/ops/populate/v0/conv2d_populate_v0.cc +++ b/mindspore/lite/src/ops/populate/v0/conv2d_populate_v0.cc @@ -24,8 +24,13 @@ namespace lite { namespace { OpParameter *PopulateConvParameter(const void *prim) { auto *primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); auto conv2d_prim = primitive->value_as_Conv2D(); - ConvParameter *conv_param = reinterpret_cast(malloc(sizeof(ConvParameter))); + if (conv2d_prim == nullptr) { + MS_LOG(ERROR) << "conv2d_prim is nullptr"; + return nullptr; + } + auto *conv_param = reinterpret_cast(malloc(sizeof(ConvParameter))); if (conv_param == nullptr) { MS_LOG(ERROR) << "malloc ConvParameter failed."; return nullptr; @@ -38,7 +43,6 @@ OpParameter *PopulateConvParameter(const void *prim) { conv_param->group_ = conv2d_prim->group(); conv_param->stride_h_ = conv2d_prim->strideH(); conv_param->stride_w_ = conv2d_prim->strideW(); - conv_param->pad_u_ = conv2d_prim->padUp(); conv_param->pad_d_ = conv2d_prim->padDown(); conv_param->pad_l_ = conv2d_prim->padLeft(); diff --git a/mindspore/lite/src/ops/populate/v0/crop_populate_v0.cc b/mindspore/lite/src/ops/populate/v0/crop_populate_v0.cc index f597dfb745..39ef66d7a1 100644 --- a/mindspore/lite/src/ops/populate/v0/crop_populate_v0.cc +++ b/mindspore/lite/src/ops/populate/v0/crop_populate_v0.cc @@ -23,14 +23,22 @@ namespace lite { namespace { OpParameter *PopulateCropParameter(const void *prim) { auto *primitive = static_cast(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(malloc(sizeof(CropParameter))); + auto *crop_param = reinterpret_cast(malloc(sizeof(CropParameter))); if (crop_param == nullptr) { MS_LOG(ERROR) << "malloc CropParameter failed."; return nullptr; diff --git a/mindspore/lite/src/ops/populate/v0/custom_extract_features_populate_v0.cc b/mindspore/lite/src/ops/populate/v0/custom_extract_features_populate_v0.cc index 06c5ba9d45..684f489ee4 100644 --- a/mindspore/lite/src/ops/populate/v0/custom_extract_features_populate_v0.cc +++ b/mindspore/lite/src/ops/populate/v0/custom_extract_features_populate_v0.cc @@ -21,13 +21,15 @@ namespace mindspore { namespace lite { namespace { OpParameter *PopulateExtractFeaturesParameter(const void *prim) { - OpParameter *param = reinterpret_cast(malloc(sizeof(OpParameter))); + auto *param = reinterpret_cast(malloc(sizeof(OpParameter))); if (param == nullptr) { MS_LOG(ERROR) << "new OpParameter failed."; return nullptr; } memset(param, 0, sizeof(OpParameter)); - auto type = reinterpret_cast(prim)->value_type(); + auto *primitive = reinterpret_cast(prim); + MS_ASSERT(primitive != nullptr); + auto type = primitive->value_type(); if (type == schema::v0::PrimitiveType_CustomExtractFeatures) { param->type_ = schema::PrimitiveType_CustomExtractFeatures; } else { diff --git a/mindspore/lite/src/ops/populate/v0/custom_normalize_populate_v0.cc b/mindspore/lite/src/ops/populate/v0/custom_normalize_populate_v0.cc index 2ee2c36d1f..c8e39edbe4 100644 --- a/mindspore/lite/src/ops/populate/v0/custom_normalize_populate_v0.cc +++ b/mindspore/lite/src/ops/populate/v0/custom_normalize_populate_v0.cc @@ -21,13 +21,15 @@ namespace mindspore { namespace lite { namespace { OpParameter *PopulateCustomNormalizeParameter(const void *prim) { - OpParameter *param = reinterpret_cast(malloc(sizeof(OpParameter))); + auto *param = reinterpret_cast(malloc(sizeof(OpParameter))); if (param == nullptr) { MS_LOG(ERROR) << "new OpParameter failed."; return nullptr; } memset(param, 0, sizeof(OpParameter)); - auto type = reinterpret_cast(prim)->value_type(); + auto *primitive = reinterpret_cast(prim); + MS_ASSERT(primitive != nullptr); + auto type = primitive->value_type(); if (type == schema::v0::PrimitiveType_CustomNormalize) { param->type_ = schema::PrimitiveType_CustomNormalize; } else { diff --git a/mindspore/lite/src/ops/populate/v0/custom_predict_populate_v0.cc b/mindspore/lite/src/ops/populate/v0/custom_predict_populate_v0.cc index 990e8e5c1e..c18ae05f63 100644 --- a/mindspore/lite/src/ops/populate/v0/custom_predict_populate_v0.cc +++ b/mindspore/lite/src/ops/populate/v0/custom_predict_populate_v0.cc @@ -23,8 +23,13 @@ namespace lite { namespace { OpParameter *PopulateCustomPredictParameter(const void *prim) { auto *primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); auto custom_predict_prim = primitive->value_as_CustomPredict(); - PredictParameter *param = reinterpret_cast(malloc(sizeof(PredictParameter))); + if (custom_predict_prim == nullptr) { + MS_LOG(ERROR) << "custom_predict_prim is nullptr"; + return nullptr; + } + auto *param = reinterpret_cast(malloc(sizeof(PredictParameter))); if (param == nullptr) { MS_LOG(ERROR) << "malloc param failed."; return nullptr; diff --git a/mindspore/lite/src/ops/populate/v0/deconv2d_populate_v0.cc b/mindspore/lite/src/ops/populate/v0/deconv2d_populate_v0.cc index f25ee53454..44c8dc78ab 100644 --- a/mindspore/lite/src/ops/populate/v0/deconv2d_populate_v0.cc +++ b/mindspore/lite/src/ops/populate/v0/deconv2d_populate_v0.cc @@ -23,8 +23,13 @@ namespace lite { namespace { OpParameter *PopulateDeconvParameter(const void *prim) { auto *primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); auto deconv2d_prim = primitive->value_as_DeConv2D(); - ConvParameter *conv_param = reinterpret_cast(malloc(sizeof(ConvParameter))); + if (deconv2d_prim == nullptr) { + MS_LOG(ERROR) << "deconv2d_prim is nullptr"; + return nullptr; + } + auto *conv_param = reinterpret_cast(malloc(sizeof(ConvParameter))); if (conv_param == nullptr) { MS_LOG(ERROR) << "malloc ConvParameter failed."; return nullptr; diff --git a/mindspore/lite/src/ops/populate/v0/dedepthwise_conv2d_populate_v0.cc b/mindspore/lite/src/ops/populate/v0/dedepthwise_conv2d_populate_v0.cc index 5463f2520a..005f344ed9 100644 --- a/mindspore/lite/src/ops/populate/v0/dedepthwise_conv2d_populate_v0.cc +++ b/mindspore/lite/src/ops/populate/v0/dedepthwise_conv2d_populate_v0.cc @@ -21,11 +21,15 @@ namespace mindspore { namespace lite { namespace { - OpParameter *PopulateDeconvDwParameter(const void *prim) { auto *primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); auto dedepthwise_conv2d_prim = primitive->value_as_DeDepthwiseConv2D(); - ConvParameter *conv_param = reinterpret_cast(malloc(sizeof(ConvParameter))); + if (dedepthwise_conv2d_prim == nullptr) { + MS_LOG(ERROR) << "dedepthwise_conv2d_prim is nullptr"; + return nullptr; + } + auto *conv_param = reinterpret_cast(malloc(sizeof(ConvParameter))); if (conv_param == nullptr) { MS_LOG(ERROR) << "malloc ConvParameter failed."; return nullptr; @@ -34,12 +38,10 @@ OpParameter *PopulateDeconvDwParameter(const void *prim) { conv_param->op_parameter_.type_ = schema::PrimitiveType_Conv2dTransposeFusion; conv_param->group_ = dedepthwise_conv2d_prim->channelIn(); - conv_param->kernel_h_ = dedepthwise_conv2d_prim->kernelH(); conv_param->kernel_w_ = dedepthwise_conv2d_prim->kernelW(); conv_param->stride_h_ = dedepthwise_conv2d_prim->strideH(); conv_param->stride_w_ = dedepthwise_conv2d_prim->strideW(); - conv_param->pad_u_ = dedepthwise_conv2d_prim->padUp(); conv_param->pad_d_ = dedepthwise_conv2d_prim->padDown(); conv_param->pad_l_ = dedepthwise_conv2d_prim->padLeft(); diff --git a/mindspore/lite/src/ops/populate/v0/depth_to_space_populate_v0.cc b/mindspore/lite/src/ops/populate/v0/depth_to_space_populate_v0.cc index 0f5e4975f2..2a252eaf52 100644 --- a/mindspore/lite/src/ops/populate/v0/depth_to_space_populate_v0.cc +++ b/mindspore/lite/src/ops/populate/v0/depth_to_space_populate_v0.cc @@ -21,12 +21,15 @@ namespace mindspore { namespace lite { namespace { - OpParameter *PopulateDepthToSpaceParameter(const void *prim) { auto *primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); auto depth_to_space_prim = primitive->value_as_DepthToSpace(); - DepthToSpaceParameter *depth_space_param = - reinterpret_cast(malloc(sizeof(DepthToSpaceParameter))); + if (depth_to_space_prim == nullptr) { + MS_LOG(ERROR) << "depth_to_space_prim is nullptr"; + return nullptr; + } + auto *depth_space_param = reinterpret_cast(malloc(sizeof(DepthToSpaceParameter))); if (depth_space_param == nullptr) { MS_LOG(ERROR) << "malloc DepthToSpaceParameter failed."; return nullptr; diff --git a/mindspore/lite/src/ops/populate/v0/depthwise_conv2d_populate_v0.cc b/mindspore/lite/src/ops/populate/v0/depthwise_conv2d_populate_v0.cc index 0a42852a85..3bdd98c5ac 100644 --- a/mindspore/lite/src/ops/populate/v0/depthwise_conv2d_populate_v0.cc +++ b/mindspore/lite/src/ops/populate/v0/depthwise_conv2d_populate_v0.cc @@ -23,8 +23,13 @@ namespace lite { namespace { OpParameter *PopulateConvDwParameter(const void *prim) { auto *primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); auto depthwise_conv2d_prim = primitive->value_as_DepthwiseConv2D(); - ConvParameter *conv_param = reinterpret_cast(malloc(sizeof(ConvParameter))); + if (depthwise_conv2d_prim == nullptr) { + MS_LOG(ERROR) << "depthwise_conv2d_prim is nullptr"; + return nullptr; + } + auto *conv_param = reinterpret_cast(malloc(sizeof(ConvParameter))); if (conv_param == nullptr) { MS_LOG(ERROR) << "malloc ConvParameter failed."; return nullptr; @@ -33,12 +38,10 @@ OpParameter *PopulateConvDwParameter(const void *prim) { conv_param->op_parameter_.type_ = schema::PrimitiveType_Conv2DFusion; conv_param->group_ = depthwise_conv2d_prim->channelIn(); - conv_param->kernel_h_ = depthwise_conv2d_prim->kernelH(); conv_param->kernel_w_ = depthwise_conv2d_prim->kernelW(); conv_param->stride_h_ = depthwise_conv2d_prim->strideH(); conv_param->stride_w_ = depthwise_conv2d_prim->strideW(); - conv_param->pad_u_ = depthwise_conv2d_prim->padUp(); conv_param->pad_d_ = depthwise_conv2d_prim->padDown(); conv_param->pad_l_ = depthwise_conv2d_prim->padLeft(); diff --git a/mindspore/lite/src/ops/populate/v0/detection_post_process_populate_v0.cc b/mindspore/lite/src/ops/populate/v0/detection_post_process_populate_v0.cc index 499ff04900..427108d9a8 100644 --- a/mindspore/lite/src/ops/populate/v0/detection_post_process_populate_v0.cc +++ b/mindspore/lite/src/ops/populate/v0/detection_post_process_populate_v0.cc @@ -23,8 +23,13 @@ namespace lite { namespace { OpParameter *PopulateDetectionPostProcessParameter(const void *prim) { auto *primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); auto detection_post_process_prim = primitive->value_as_DetectionPostProcess(); - DetectionPostProcessParameter *detection_post_process_parameter = + if (detection_post_process_prim == nullptr) { + MS_LOG(ERROR) << "detection_post_process_prim is nullptr"; + return nullptr; + } + auto *detection_post_process_parameter = reinterpret_cast(malloc(sizeof(DetectionPostProcessParameter))); if (detection_post_process_parameter == nullptr) { MS_LOG(ERROR) << "malloc EluParameter failed."; diff --git a/mindspore/lite/src/ops/populate/v0/div_populate_v0.cc b/mindspore/lite/src/ops/populate/v0/div_populate_v0.cc index ead45f94c7..99d23731bd 100644 --- a/mindspore/lite/src/ops/populate/v0/div_populate_v0.cc +++ b/mindspore/lite/src/ops/populate/v0/div_populate_v0.cc @@ -23,8 +23,13 @@ namespace lite { namespace { OpParameter *PopulateDivParameter(const void *prim) { auto *primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); auto div_prim = primitive->value_as_Div(); - ArithmeticParameter *param = PopulateArithmeticCommonPara(primitive); + if (div_prim == nullptr) { + MS_LOG(ERROR) << "div_prim is nullptr"; + return nullptr; + } + auto *param = PopulateArithmeticCommonPara(primitive); if (param == nullptr) { MS_LOG(ERROR) << "PopulateArithmeticCommonPara failed."; return nullptr; diff --git a/mindspore/lite/src/ops/populate/v0/eltwise_populate_v0.cc b/mindspore/lite/src/ops/populate/v0/eltwise_populate_v0.cc index 327c708347..58cb106684 100644 --- a/mindspore/lite/src/ops/populate/v0/eltwise_populate_v0.cc +++ b/mindspore/lite/src/ops/populate/v0/eltwise_populate_v0.cc @@ -23,12 +23,19 @@ namespace lite { namespace { OpParameter *PopulateEltwiseParameter(const void *prim) { auto *primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); + auto eltwise_prim = primitive->value_as_Eltwise(); + if (eltwise_prim == nullptr) { + MS_LOG(ERROR) << "eltwise_prim is nullptr"; + return nullptr; + } ArithmeticParameter *param = PopulateArithmeticV0CommonPara(primitive); if (param == nullptr) { MS_LOG(ERROR) << "PopulateArithmeticV0CommonPara failed."; return nullptr; } - param->eltwise_mode_ = primitive->value_as_Eltwise()->mode(); + + param->eltwise_mode_ = eltwise_prim->mode(); param->op_parameter_.type_ = schema::PrimitiveType_Eltwise; return reinterpret_cast(param); } diff --git a/mindspore/lite/src/ops/populate/v0/elu_populate_v0.cc b/mindspore/lite/src/ops/populate/v0/elu_populate_v0.cc index a65326a742..5965137a4a 100644 --- a/mindspore/lite/src/ops/populate/v0/elu_populate_v0.cc +++ b/mindspore/lite/src/ops/populate/v0/elu_populate_v0.cc @@ -23,8 +23,13 @@ namespace lite { namespace { OpParameter *PopulateEluParameter(const void *prim) { auto *primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); auto elu_prim = primitive->value_as_Elu(); - EluParameter *elu_parameter = reinterpret_cast(malloc(sizeof(EluParameter))); + if (elu_prim == nullptr) { + MS_LOG(ERROR) << "elu_prim is nullptr"; + return nullptr; + } + auto *elu_parameter = reinterpret_cast(malloc(sizeof(EluParameter))); if (elu_parameter == nullptr) { MS_LOG(ERROR) << "malloc EluParameter failed."; return nullptr; diff --git a/mindspore/lite/src/ops/populate/v0/embedding_lookup_populate_v0.cc b/mindspore/lite/src/ops/populate/v0/embedding_lookup_populate_v0.cc index 8ab55d43f2..f58e82ae6f 100644 --- a/mindspore/lite/src/ops/populate/v0/embedding_lookup_populate_v0.cc +++ b/mindspore/lite/src/ops/populate/v0/embedding_lookup_populate_v0.cc @@ -23,8 +23,13 @@ namespace lite { namespace { OpParameter *PopulateEmbeddingLookupParameter(const void *prim) { auto *primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); auto embedding_lookup_prim = primitive->value_as_EmbeddingLookup(); - EmbeddingLookupParameter *embedding_lookup_parameter = + if (embedding_lookup_prim == nullptr) { + MS_LOG(ERROR) << "embedding_lookup_prim is nullptr"; + return nullptr; + } + auto *embedding_lookup_parameter = reinterpret_cast(malloc(sizeof(EmbeddingLookupParameter))); if (embedding_lookup_parameter == nullptr) { MS_LOG(ERROR) << "malloc EmbeddingLookupParameter failed."; diff --git a/mindspore/lite/src/ops/populate/v0/exp_populate_v0.cc b/mindspore/lite/src/ops/populate/v0/exp_populate_v0.cc index 165e0db3dc..2489f5fe2e 100644 --- a/mindspore/lite/src/ops/populate/v0/exp_populate_v0.cc +++ b/mindspore/lite/src/ops/populate/v0/exp_populate_v0.cc @@ -23,8 +23,13 @@ namespace lite { namespace { OpParameter *PopulateExpParameter(const void *prim) { auto *primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); auto exp_prim = primitive->value_as_Exp(); - ExpParameter *exp_parameter = reinterpret_cast(malloc(sizeof(ExpParameter))); + if (exp_prim == nullptr) { + MS_LOG(ERROR) << "exp_prim is nullptr"; + return nullptr; + } + auto *exp_parameter = reinterpret_cast(malloc(sizeof(ExpParameter))); if (exp_parameter == nullptr) { MS_LOG(ERROR) << "malloc ExpParameter failed."; return nullptr; diff --git a/mindspore/lite/src/ops/populate/v0/full_connection_populate_v0.cc b/mindspore/lite/src/ops/populate/v0/full_connection_populate_v0.cc index 4956967daf..1eb00784a5 100644 --- a/mindspore/lite/src/ops/populate/v0/full_connection_populate_v0.cc +++ b/mindspore/lite/src/ops/populate/v0/full_connection_populate_v0.cc @@ -21,12 +21,15 @@ namespace mindspore { namespace lite { namespace { - OpParameter *PopulateFullconnectionParameter(const void *prim) { auto *primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); auto full_connection_prim = primitive->value_as_FullConnection(); - - MatMulParameter *matmul_param = reinterpret_cast(malloc(sizeof(MatMulParameter))); + if (full_connection_prim == nullptr) { + MS_LOG(ERROR) << "full_connection_prim is nullptr"; + return nullptr; + } + auto *matmul_param = reinterpret_cast(malloc(sizeof(MatMulParameter))); if (matmul_param == nullptr) { MS_LOG(ERROR) << "malloc MatMulParameter failed."; return nullptr; diff --git a/mindspore/lite/src/ops/populate/v0/fused_batchnorm_populate_v0.cc b/mindspore/lite/src/ops/populate/v0/fused_batchnorm_populate_v0.cc index f164e3c747..2f128515bb 100644 --- a/mindspore/lite/src/ops/populate/v0/fused_batchnorm_populate_v0.cc +++ b/mindspore/lite/src/ops/populate/v0/fused_batchnorm_populate_v0.cc @@ -23,8 +23,13 @@ namespace lite { namespace { OpParameter *PopulateFusedBatchNormParameter(const void *prim) { auto *primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); auto fused_batchnorm_prim = primitive->value_as_FusedBatchNorm(); - BatchNormParameter *batch_norm_param = reinterpret_cast(malloc(sizeof(BatchNormParameter))); + if (fused_batchnorm_prim == nullptr) { + MS_LOG(ERROR) << "fused_batchnorm_prim is nullptr"; + return nullptr; + } + auto *batch_norm_param = reinterpret_cast(malloc(sizeof(BatchNormParameter))); if (batch_norm_param == nullptr) { MS_LOG(ERROR) << "malloc BatchNormParameter failed."; return nullptr; diff --git a/mindspore/lite/src/ops/populate/v0/gather_populate_v0.cc b/mindspore/lite/src/ops/populate/v0/gather_populate_v0.cc index 34ecda0034..72fcc388b2 100644 --- a/mindspore/lite/src/ops/populate/v0/gather_populate_v0.cc +++ b/mindspore/lite/src/ops/populate/v0/gather_populate_v0.cc @@ -23,9 +23,13 @@ namespace lite { namespace { OpParameter *PopulateGatherParameter(const void *prim) { auto *primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); auto gather_prim = primitive->value_as_Gather(); - - GatherParameter *gather_param = reinterpret_cast(malloc(sizeof(GatherParameter))); + if (gather_prim == nullptr) { + MS_LOG(ERROR) << "gather_prim is nullptr"; + return nullptr; + } + auto *gather_param = reinterpret_cast(malloc(sizeof(GatherParameter))); if (gather_param == nullptr) { MS_LOG(ERROR) << "malloc GatherParameter failed."; return nullptr; diff --git a/mindspore/lite/src/ops/populate/v0/instance_norm_populate_v0.cc b/mindspore/lite/src/ops/populate/v0/instance_norm_populate_v0.cc index b2603c1a67..90e8c020d7 100644 --- a/mindspore/lite/src/ops/populate/v0/instance_norm_populate_v0.cc +++ b/mindspore/lite/src/ops/populate/v0/instance_norm_populate_v0.cc @@ -23,9 +23,13 @@ namespace lite { namespace { OpParameter *PopulateInstanceNormParameter(const void *prim) { auto *primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); auto instance_norm_prim = primitive->value_as_InstanceNorm(); - InstanceNormParameter *instance_norm_param = - reinterpret_cast(malloc(sizeof(InstanceNormParameter))); + if (instance_norm_prim == nullptr) { + MS_LOG(ERROR) << "instance_norm_prim is nullptr"; + return nullptr; + } + auto *instance_norm_param = reinterpret_cast(malloc(sizeof(InstanceNormParameter))); if (instance_norm_param == nullptr) { MS_LOG(ERROR) << "malloc InstanceNormParameter failed."; return nullptr; diff --git a/mindspore/lite/src/ops/populate/v0/l2_norm_populate_v0.cc b/mindspore/lite/src/ops/populate/v0/l2_norm_populate_v0.cc index 33ab4c9967..f237a5e26b 100644 --- a/mindspore/lite/src/ops/populate/v0/l2_norm_populate_v0.cc +++ b/mindspore/lite/src/ops/populate/v0/l2_norm_populate_v0.cc @@ -23,8 +23,13 @@ namespace lite { namespace { OpParameter *PopulateL2NormParameter(const void *prim) { auto *primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); auto l2_norm_prim = primitive->value_as_L2Norm(); - L2NormParameter *l2_norm_parameter = reinterpret_cast(malloc(sizeof(L2NormParameter))); + if (l2_norm_prim == nullptr) { + MS_LOG(ERROR) << "l2_norm_prim is nullptr"; + return nullptr; + } + auto *l2_norm_parameter = reinterpret_cast(malloc(sizeof(L2NormParameter))); if (l2_norm_parameter == nullptr) { MS_LOG(ERROR) << "malloc L2NormParameter failed."; return nullptr; @@ -32,8 +37,11 @@ OpParameter *PopulateL2NormParameter(const void *prim) { memset(l2_norm_parameter, 0, sizeof(L2NormParameter)); l2_norm_parameter->op_parameter_.type_ = schema::PrimitiveType_L2NormalizeFusion; - MS_ASSERT(l2_norm_prim != nullptr); auto axis_vec = l2_norm_prim->axis(); + if (axis_vec == nullptr) { + MS_LOG(ERROR) << "axis_vec is nullptr"; + return nullptr; + } l2_norm_parameter->axis_num_ = axis_vec->size(); if (((size_t)axis_vec->size()) > SIZE_MAX / sizeof(int)) { MS_LOG(ERROR) << "axis_vec size too big"; diff --git a/mindspore/lite/src/ops/populate/v0/layer_norm_populate_v0.cc b/mindspore/lite/src/ops/populate/v0/layer_norm_populate_v0.cc index a0139f1ee2..389debc064 100644 --- a/mindspore/lite/src/ops/populate/v0/layer_norm_populate_v0.cc +++ b/mindspore/lite/src/ops/populate/v0/layer_norm_populate_v0.cc @@ -23,7 +23,12 @@ namespace mindspore { namespace lite { OpParameter *PopulateLayerNormParameterV0(const void *prim) { auto *primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); auto layer_norm_prim = primitive->value_as_LayerNorm(); + if (layer_norm_prim == nullptr) { + MS_LOG(ERROR) << "layer_norm_prim is nullptr"; + return nullptr; + } auto layer_norm_parameter = reinterpret_cast(malloc(sizeof(LayerNormParameter))); if (layer_norm_parameter == nullptr) { MS_LOG(ERROR) << "malloc LayerNormParameter failed."; diff --git a/mindspore/lite/src/ops/populate/v0/local_response_normalization_populate_v0.cc b/mindspore/lite/src/ops/populate/v0/local_response_normalization_populate_v0.cc index 8a3f028c48..e0c34be280 100644 --- a/mindspore/lite/src/ops/populate/v0/local_response_normalization_populate_v0.cc +++ b/mindspore/lite/src/ops/populate/v0/local_response_normalization_populate_v0.cc @@ -23,10 +23,13 @@ namespace lite { namespace { OpParameter *PopulateLocalResponseNormParameter(const void *prim) { auto *primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); auto local_response_normalization_prim = primitive->value_as_LocalResponseNormalization(); - - LocalResponseNormParameter *lrn_param = - reinterpret_cast(malloc(sizeof(LocalResponseNormParameter))); + if (local_response_normalization_prim == nullptr) { + MS_LOG(ERROR) << "local_response_normalization_prim is nullptr"; + return nullptr; + } + auto *lrn_param = reinterpret_cast(malloc(sizeof(LocalResponseNormParameter))); if (lrn_param == nullptr) { MS_LOG(ERROR) << "malloc LocalResponseNormParameter failed."; return nullptr; diff --git a/mindspore/lite/src/ops/populate/v0/lsh_projection_populate_v0.cc b/mindspore/lite/src/ops/populate/v0/lsh_projection_populate_v0.cc index 1292c5e013..2511a56618 100644 --- a/mindspore/lite/src/ops/populate/v0/lsh_projection_populate_v0.cc +++ b/mindspore/lite/src/ops/populate/v0/lsh_projection_populate_v0.cc @@ -23,9 +23,13 @@ namespace lite { namespace { OpParameter *PopulateLshProjectionParameter(const void *prim) { auto *primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); auto lsh_projection_prim = primitive->value_as_LshProjection(); - LshProjectionParameter *lsh_project_param = - reinterpret_cast(malloc(sizeof(LshProjectionParameter))); + if (lsh_projection_prim == nullptr) { + MS_LOG(ERROR) << "lsh_projection_prim is nullptr"; + return nullptr; + } + auto *lsh_project_param = reinterpret_cast(malloc(sizeof(LshProjectionParameter))); if (lsh_project_param == nullptr) { MS_LOG(ERROR) << "malloc LshProjectionParameter failed."; return nullptr; diff --git a/mindspore/lite/src/ops/populate/v0/lstm_populate_v0.cc b/mindspore/lite/src/ops/populate/v0/lstm_populate_v0.cc index 701909fd14..7b44e203bf 100644 --- a/mindspore/lite/src/ops/populate/v0/lstm_populate_v0.cc +++ b/mindspore/lite/src/ops/populate/v0/lstm_populate_v0.cc @@ -23,8 +23,13 @@ namespace lite { namespace { OpParameter *PopulateLstmParameter(const void *prim) { auto *primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); auto lstm_prim = primitive->value_as_Lstm(); - LstmParameter *lstm_param = reinterpret_cast(malloc(sizeof(LstmParameter))); + if (lstm_prim == nullptr) { + MS_LOG(ERROR) << "lstm_prim is nullptr"; + return nullptr; + } + auto *lstm_param = reinterpret_cast(malloc(sizeof(LstmParameter))); if (lstm_param == nullptr) { MS_LOG(ERROR) << "malloc LstmParameter failed."; return nullptr; @@ -32,11 +37,6 @@ OpParameter *PopulateLstmParameter(const void *prim) { memset(lstm_param, 0, sizeof(LstmParameter)); lstm_param->op_parameter_.type_ = schema::PrimitiveType_LSTM; - if (lstm_prim == nullptr) { - free(lstm_param); - MS_LOG(ERROR) << "get Lstm param nullptr."; - return nullptr; - } lstm_param->bidirectional_ = lstm_prim->bidirection(); return reinterpret_cast(lstm_param); } diff --git a/mindspore/lite/src/ops/populate/v0/matmul_populate_v0.cc b/mindspore/lite/src/ops/populate/v0/matmul_populate_v0.cc index 41d100e922..cacdaaa45f 100644 --- a/mindspore/lite/src/ops/populate/v0/matmul_populate_v0.cc +++ b/mindspore/lite/src/ops/populate/v0/matmul_populate_v0.cc @@ -23,9 +23,13 @@ namespace lite { namespace { OpParameter *PopulateMatMulParameter(const void *prim) { auto *primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); auto matmul_prim = primitive->value_as_MatMul(); - - MatMulParameter *matmul_param = reinterpret_cast(malloc(sizeof(MatMulParameter))); + if (matmul_prim == nullptr) { + MS_LOG(ERROR) << "matmul_prim is nullptr"; + return nullptr; + } + auto *matmul_param = reinterpret_cast(malloc(sizeof(MatMulParameter))); if (matmul_param == nullptr) { MS_LOG(ERROR) << "malloc MatMulParameter failed."; return nullptr; diff --git a/mindspore/lite/src/ops/populate/v0/mul_populate_v0.cc b/mindspore/lite/src/ops/populate/v0/mul_populate_v0.cc index a8b5b3a9ea..934febb2ea 100644 --- a/mindspore/lite/src/ops/populate/v0/mul_populate_v0.cc +++ b/mindspore/lite/src/ops/populate/v0/mul_populate_v0.cc @@ -23,8 +23,13 @@ namespace lite { namespace { OpParameter *PopulateMulParameter(const void *prim) { auto *primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); auto mul_prim = primitive->value_as_Mul(); - ArithmeticParameter *param = PopulateArithmeticCommonPara(primitive); + if (mul_prim == nullptr) { + MS_LOG(ERROR) << "mul_prim is nullptr"; + return nullptr; + } + auto *param = PopulateArithmeticCommonPara(primitive); if (param == nullptr) { MS_LOG(ERROR) << "PopulateArithmeticCommonPara failed."; return nullptr; diff --git a/mindspore/lite/src/ops/populate/v0/non_max_suppression_populate_v0.cc b/mindspore/lite/src/ops/populate/v0/non_max_suppression_populate_v0.cc index 3193862a4c..d14f3720b0 100644 --- a/mindspore/lite/src/ops/populate/v0/non_max_suppression_populate_v0.cc +++ b/mindspore/lite/src/ops/populate/v0/non_max_suppression_populate_v0.cc @@ -23,8 +23,13 @@ namespace lite { namespace { OpParameter *PopulateNonMaxSuppressionParameter(const void *prim) { auto *primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); auto non_max_suppression_prim = primitive->value_as_NonMaxSuppression(); - NMSParameter *param = reinterpret_cast(malloc(sizeof(NMSParameter))); + if (non_max_suppression_prim == nullptr) { + MS_LOG(ERROR) << "non_max_suppression_prim is nullptr"; + return nullptr; + } + auto *param = reinterpret_cast(malloc(sizeof(NMSParameter))); if (param == nullptr) { MS_LOG(ERROR) << "malloc param failed."; return nullptr; diff --git a/mindspore/lite/src/ops/populate/v0/one_hot_populate_v0.cc b/mindspore/lite/src/ops/populate/v0/one_hot_populate_v0.cc index 332c903f91..75650dbf52 100644 --- a/mindspore/lite/src/ops/populate/v0/one_hot_populate_v0.cc +++ b/mindspore/lite/src/ops/populate/v0/one_hot_populate_v0.cc @@ -23,20 +23,19 @@ namespace lite { namespace { OpParameter *PopulateOneHotParameter(const void *prim) { auto *primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); auto one_hot_prim = primitive->value_as_OneHot(); - OneHotParameter *one_hot_param = reinterpret_cast(malloc(sizeof(OneHotParameter))); + if (one_hot_prim == nullptr) { + MS_LOG(ERROR) << "one_hot_prim is nullptr"; + return nullptr; + } + auto *one_hot_param = reinterpret_cast(malloc(sizeof(OneHotParameter))); if (one_hot_param == nullptr) { MS_LOG(ERROR) << "malloc OneHotParameter failed."; return nullptr; } memset(one_hot_param, 0, sizeof(OneHotParameter)); one_hot_param->op_parameter_.type_ = schema::PrimitiveType_OneHot; - - if (one_hot_prim == nullptr) { - free(one_hot_param); - MS_LOG(ERROR) << "get OneHot param nullptr."; - return nullptr; - } one_hot_param->axis_ = one_hot_prim->axis(); return reinterpret_cast(one_hot_param); } diff --git a/mindspore/lite/src/ops/populate/v0/p_relu_populate_v0.cc b/mindspore/lite/src/ops/populate/v0/p_relu_populate_v0.cc index 3cee353dde..a57d95cba8 100644 --- a/mindspore/lite/src/ops/populate/v0/p_relu_populate_v0.cc +++ b/mindspore/lite/src/ops/populate/v0/p_relu_populate_v0.cc @@ -23,9 +23,13 @@ namespace lite { namespace { OpParameter *PopulatePReLUParameter(const void *prim) { auto *primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); auto p_relu_prim = primitive->value_as_PReLU(); - - PReluParameter *prelu_param = reinterpret_cast(malloc(sizeof(PReluParameter))); + if (p_relu_prim == nullptr) { + MS_LOG(ERROR) << "p_relu_prim is nullptr"; + return nullptr; + } + auto *prelu_param = reinterpret_cast(malloc(sizeof(PReluParameter))); if (prelu_param == nullptr) { MS_LOG(ERROR) << "malloc PReluParameter failed."; return nullptr; diff --git a/mindspore/lite/src/ops/populate/v0/pad_populate_v0.cc b/mindspore/lite/src/ops/populate/v0/pad_populate_v0.cc index 1ed05e2a61..e7eba86b1d 100644 --- a/mindspore/lite/src/ops/populate/v0/pad_populate_v0.cc +++ b/mindspore/lite/src/ops/populate/v0/pad_populate_v0.cc @@ -23,8 +23,13 @@ namespace lite { namespace { OpParameter *PopulatePadParameter(const void *prim) { auto *primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); auto pad_prim = primitive->value_as_Pad(); - PadParameter *pad_param = reinterpret_cast(malloc(sizeof(PadParameter))); + if (pad_prim == nullptr) { + MS_LOG(ERROR) << "pad_prim is nullptr"; + return nullptr; + } + auto *pad_param = reinterpret_cast(malloc(sizeof(PadParameter))); if (pad_param == nullptr) { MS_LOG(ERROR) << "malloc PadParameter failed."; return nullptr; diff --git a/mindspore/lite/src/ops/populate/v0/partial_populate_v0.cc b/mindspore/lite/src/ops/populate/v0/partial_populate_v0.cc index 553f371915..72e63de71d 100644 --- a/mindspore/lite/src/ops/populate/v0/partial_populate_v0.cc +++ b/mindspore/lite/src/ops/populate/v0/partial_populate_v0.cc @@ -27,8 +27,13 @@ typedef struct PartialParameter { OpParameter *PopulatePartialParameter(const void *prim) { auto *primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); auto partial_prim = primitive->value_as_Partial(); - PartialParameter *partial_parameter = reinterpret_cast(malloc(sizeof(PartialParameter))); + if (partial_prim == nullptr) { + MS_LOG(ERROR) << "partial_prim is nullptr"; + return nullptr; + } + auto *partial_parameter = reinterpret_cast(malloc(sizeof(PartialParameter))); if (partial_parameter == nullptr) { MS_LOG(ERROR) << "malloc partial parameter failed."; return nullptr; diff --git a/mindspore/lite/src/ops/populate/v0/pooling_populate_v0.cc b/mindspore/lite/src/ops/populate/v0/pooling_populate_v0.cc index 3c074bc7bf..8b5c46b1fd 100644 --- a/mindspore/lite/src/ops/populate/v0/pooling_populate_v0.cc +++ b/mindspore/lite/src/ops/populate/v0/pooling_populate_v0.cc @@ -23,9 +23,13 @@ namespace lite { namespace { OpParameter *PopulatePoolingParameter(const void *prim) { auto *primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); auto pooling_prim = primitive->value_as_Pooling(); - - PoolingParameter *pooling_param = reinterpret_cast(malloc(sizeof(PoolingParameter))); + if (pooling_prim == nullptr) { + MS_LOG(ERROR) << "pooling_prim is nullptr"; + return nullptr; + } + auto *pooling_param = reinterpret_cast(malloc(sizeof(PoolingParameter))); if (pooling_param == nullptr) { MS_LOG(ERROR) << "malloc PoolingParameter failed."; return nullptr; diff --git a/mindspore/lite/src/ops/populate/v0/power_populate_v0.cc b/mindspore/lite/src/ops/populate/v0/power_populate_v0.cc index b7391b0828..d1fc22c111 100644 --- a/mindspore/lite/src/ops/populate/v0/power_populate_v0.cc +++ b/mindspore/lite/src/ops/populate/v0/power_populate_v0.cc @@ -23,8 +23,13 @@ namespace lite { namespace { OpParameter *PopulatePowerParameter(const void *prim) { auto *primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); auto power_prim = primitive->value_as_Power(); - PowerParameter *power_param = reinterpret_cast(malloc(sizeof(PowerParameter))); + if (power_prim == nullptr) { + MS_LOG(ERROR) << "power_prim is nullptr"; + return nullptr; + } + auto *power_param = reinterpret_cast(malloc(sizeof(PowerParameter))); if (power_param == nullptr) { MS_LOG(ERROR) << "malloc PowerParameter failed."; return nullptr; diff --git a/mindspore/lite/src/ops/populate/v0/prior_box_populate_v0.cc b/mindspore/lite/src/ops/populate/v0/prior_box_populate_v0.cc index 7c5c1ef78c..f74b46ea54 100644 --- a/mindspore/lite/src/ops/populate/v0/prior_box_populate_v0.cc +++ b/mindspore/lite/src/ops/populate/v0/prior_box_populate_v0.cc @@ -23,8 +23,13 @@ namespace lite { namespace { OpParameter *PopulatePriorBoxParameter(const void *prim) { auto *primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); auto prior_box_prim = primitive->value_as_PriorBox(); - PriorBoxParameter *prior_box_param = reinterpret_cast(malloc(sizeof(PriorBoxParameter))); + if (prior_box_prim == nullptr) { + MS_LOG(ERROR) << "prior_box_prim is nullptr"; + return nullptr; + } + auto *prior_box_param = reinterpret_cast(malloc(sizeof(PriorBoxParameter))); if (prior_box_param == nullptr) { MS_LOG(ERROR) << "malloc PriorBoxParameter failed."; return nullptr; @@ -32,41 +37,57 @@ OpParameter *PopulatePriorBoxParameter(const void *prim) { memset(prior_box_param, 0, sizeof(PriorBoxParameter)); prior_box_param->op_parameter_.type_ = schema::PrimitiveType_PriorBox; - if (prior_box_prim->min_sizes()->size() > MAX_SHAPE_SIZE) { - MS_LOG(ERROR) << "PriorBox min_sizes size exceeds max num " << MAX_SHAPE_SIZE << ", got " - << prior_box_prim->min_sizes(); + auto min_sizes = prior_box_prim->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; free(prior_box_param); return nullptr; } - prior_box_param->min_sizes_size = prior_box_prim->min_sizes()->size(); - if (prior_box_prim->max_sizes()->size() > MAX_SHAPE_SIZE) { - MS_LOG(ERROR) << "PriorBox max_sizes size exceeds max num " << MAX_SHAPE_SIZE << ", got " - << prior_box_prim->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 = prior_box_prim->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; free(prior_box_param); return nullptr; } - prior_box_param->max_sizes_size = prior_box_prim->max_sizes()->size(); - memcpy(prior_box_param->max_sizes, prior_box_prim->max_sizes()->data(), - prior_box_prim->max_sizes()->size() * sizeof(int32_t)); - memcpy(prior_box_param->min_sizes, prior_box_prim->min_sizes()->data(), - prior_box_prim->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 (prior_box_prim->aspect_ratios()->size() > MAX_SHAPE_SIZE) { - MS_LOG(ERROR) << "PriorBox aspect_ratios size exceeds max num " << MAX_SHAPE_SIZE << ", got " - << prior_box_prim->aspect_ratios(); + auto aspect_ratios = prior_box_prim->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 " << aspect_ratios; free(prior_box_param); return nullptr; } - prior_box_param->aspect_ratios_size = prior_box_prim->aspect_ratios()->size(); - memcpy(prior_box_param->aspect_ratios, prior_box_prim->aspect_ratios()->data(), - prior_box_prim->aspect_ratios()->size() * sizeof(float)); - if (prior_box_prim->variances()->size() != COMM_SHAPE_SIZE) { - MS_LOG(ERROR) << "PriorBox variances size should be " << COMM_SHAPE_SIZE << ", got " - << prior_box_prim->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 = prior_box_prim->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, prior_box_prim->variances()->data(), COMM_SHAPE_SIZE * sizeof(float)); + memcpy(prior_box_param->variances, variances->data(), COMM_SHAPE_SIZE * sizeof(float)); + prior_box_param->flip = prior_box_prim->flip(); prior_box_param->clip = prior_box_prim->clip(); prior_box_param->offset = prior_box_prim->offset(); diff --git a/mindspore/lite/src/ops/populate/v0/quant_dtype_cast_populate_v0.cc b/mindspore/lite/src/ops/populate/v0/quant_dtype_cast_populate_v0.cc index b4df8a9cc5..920d9ba54d 100644 --- a/mindspore/lite/src/ops/populate/v0/quant_dtype_cast_populate_v0.cc +++ b/mindspore/lite/src/ops/populate/v0/quant_dtype_cast_populate_v0.cc @@ -23,9 +23,13 @@ namespace lite { namespace { OpParameter *PopulateQuantDTypeCastParameter(const void *prim) { auto *primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); auto quant_dtype_cast_prim = primitive->value_as_QuantDTypeCast(); - QuantDTypeCastParameter *parameter = - reinterpret_cast(malloc(sizeof(QuantDTypeCastParameter))); + if (quant_dtype_cast_prim == nullptr) { + MS_LOG(ERROR) << "quant_dtype_cast_prim is nullptr"; + return nullptr; + } + auto *parameter = reinterpret_cast(malloc(sizeof(QuantDTypeCastParameter))); if (parameter == nullptr) { MS_LOG(ERROR) << "malloc QuantDTypeCastParameter failed."; return nullptr; diff --git a/mindspore/lite/src/ops/populate/v0/range_populate_v0.cc b/mindspore/lite/src/ops/populate/v0/range_populate_v0.cc index 52200f24e7..f2b964c50b 100644 --- a/mindspore/lite/src/ops/populate/v0/range_populate_v0.cc +++ b/mindspore/lite/src/ops/populate/v0/range_populate_v0.cc @@ -23,9 +23,13 @@ namespace lite { namespace { OpParameter *PopulateRangeParameter(const void *prim) { auto *primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); auto range_prim = primitive->value_as_Range(); - - RangeParameter *range_param = reinterpret_cast(malloc(sizeof(RangeParameter))); + if (range_prim == nullptr) { + MS_LOG(ERROR) << "range_prim is nullptr"; + return nullptr; + } + auto *range_param = reinterpret_cast(malloc(sizeof(RangeParameter))); if (range_param == nullptr) { MS_LOG(ERROR) << "malloc RangeParameter failed."; return nullptr; diff --git a/mindspore/lite/src/ops/populate/v0/reduce_populate_v0.cc b/mindspore/lite/src/ops/populate/v0/reduce_populate_v0.cc index c23faa5299..033a908d19 100644 --- a/mindspore/lite/src/ops/populate/v0/reduce_populate_v0.cc +++ b/mindspore/lite/src/ops/populate/v0/reduce_populate_v0.cc @@ -23,8 +23,13 @@ namespace lite { namespace { OpParameter *PopulateReduceParameter(const void *prim) { auto *primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); auto reduce_prim = primitive->value_as_Reduce(); - ReduceParameter *reduce_param = reinterpret_cast(malloc(sizeof(ReduceParameter))); + if (reduce_prim == nullptr) { + MS_LOG(ERROR) << "reduce_prim is nullptr"; + return nullptr; + } + auto *reduce_param = reinterpret_cast(malloc(sizeof(ReduceParameter))); if (reduce_param == nullptr) { MS_LOG(ERROR) << "malloc ReduceParameter failed."; return nullptr; @@ -36,6 +41,10 @@ OpParameter *PopulateReduceParameter(const void *prim) { reduce_param->reduce_to_end_ = reduce_prim->reduceToEnd(); reduce_param->coeff = reduce_prim->coeff(); auto axisVector = reduce_prim->axes(); + if (axisVector == nullptr) { + MS_LOG(ERROR) << "axisVector is nullptr"; + return nullptr; + } if (axisVector->size() > MAX_SHAPE_SIZE) { MS_LOG(ERROR) << "Reduce axes size " << axisVector->size() << " exceed limit " << MAX_SHAPE_SIZE; free(reduce_param); diff --git a/mindspore/lite/src/ops/populate/v0/resize_populate_v0.cc b/mindspore/lite/src/ops/populate/v0/resize_populate_v0.cc index a759c153b7..035f416828 100644 --- a/mindspore/lite/src/ops/populate/v0/resize_populate_v0.cc +++ b/mindspore/lite/src/ops/populate/v0/resize_populate_v0.cc @@ -23,8 +23,13 @@ namespace lite { namespace { OpParameter *PopulateResizeParameter(const void *prim) { auto *primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); auto resize_prim = primitive->value_as_Resize(); - ResizeParameter *resize_param = reinterpret_cast(malloc(sizeof(ResizeParameter))); + if (resize_prim == nullptr) { + MS_LOG(ERROR) << "resize_prim is nullptr"; + return nullptr; + } + auto *resize_param = reinterpret_cast(malloc(sizeof(ResizeParameter))); if (resize_param == nullptr) { MS_LOG(ERROR) << "malloc ResizeParameter failed."; return nullptr; diff --git a/mindspore/lite/src/ops/populate/v0/reverse_populate_v0.cc b/mindspore/lite/src/ops/populate/v0/reverse_populate_v0.cc index 6f45635fd8..a66547d400 100644 --- a/mindspore/lite/src/ops/populate/v0/reverse_populate_v0.cc +++ b/mindspore/lite/src/ops/populate/v0/reverse_populate_v0.cc @@ -23,9 +23,13 @@ namespace lite { namespace { OpParameter *PopulateReverseParameter(const void *prim) { auto *primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); auto reverse_prim = primitive->value_as_Reverse(); - - ReverseParameter *reverse_param = reinterpret_cast(malloc(sizeof(ReverseParameter))); + if (reverse_prim == nullptr) { + MS_LOG(ERROR) << "reverse_prim is nullptr"; + return nullptr; + } + auto *reverse_param = reinterpret_cast(malloc(sizeof(ReverseParameter))); if (reverse_param == nullptr) { MS_LOG(ERROR) << "malloc ReverseParameter failed."; return nullptr; @@ -33,6 +37,10 @@ OpParameter *PopulateReverseParameter(const void *prim) { memset(reverse_param, 0, sizeof(ReverseParameter)); reverse_param->op_parameter_.type_ = schema::PrimitiveType_ReverseV2; auto flatAxis = reverse_prim->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++) { diff --git a/mindspore/lite/src/ops/populate/v0/reverse_sequence_populate_v0.cc b/mindspore/lite/src/ops/populate/v0/reverse_sequence_populate_v0.cc index f4782daea7..305be9de03 100644 --- a/mindspore/lite/src/ops/populate/v0/reverse_sequence_populate_v0.cc +++ b/mindspore/lite/src/ops/populate/v0/reverse_sequence_populate_v0.cc @@ -23,9 +23,13 @@ namespace lite { namespace { OpParameter *PopulateReverseSequenceParameter(const void *prim) { auto *primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); auto reverse_sequence_prim = primitive->value_as_ReverseSequence(); - ReverseSequenceParameter *reverse_sequence_param = - reinterpret_cast(malloc(sizeof(ReverseSequenceParameter))); + if (reverse_sequence_prim == nullptr) { + MS_LOG(ERROR) << "reverse_sequence_prim is nullptr"; + return nullptr; + } + auto *reverse_sequence_param = reinterpret_cast(malloc(sizeof(ReverseSequenceParameter))); if (reverse_sequence_param == nullptr) { MS_LOG(ERROR) << "malloc ReverseSequenceParameter failed."; return nullptr; diff --git a/mindspore/lite/src/ops/populate/v0/roi_pooling_populate_v0.cc b/mindspore/lite/src/ops/populate/v0/roi_pooling_populate_v0.cc index 59d07c90d2..ae49c335c7 100644 --- a/mindspore/lite/src/ops/populate/v0/roi_pooling_populate_v0.cc +++ b/mindspore/lite/src/ops/populate/v0/roi_pooling_populate_v0.cc @@ -23,9 +23,13 @@ namespace lite { namespace { OpParameter *PopulateROIPoolingParameter(const void *prim) { auto *primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); auto roi_pooling_prim = primitive->value_as_ROIPooling(); - - ROIPoolingParameter *roi_pooling_param = reinterpret_cast(malloc(sizeof(ROIPoolingParameter))); + if (roi_pooling_prim == nullptr) { + MS_LOG(ERROR) << "roi_pooling_prim is nullptr"; + return nullptr; + } + auto *roi_pooling_param = reinterpret_cast(malloc(sizeof(ROIPoolingParameter))); if (roi_pooling_param == nullptr) { MS_LOG(ERROR) << "malloc ROIPoolingParameter failed."; return nullptr; diff --git a/mindspore/lite/src/ops/populate/v0/scale_populate_v0.cc b/mindspore/lite/src/ops/populate/v0/scale_populate_v0.cc index 59d778a101..16b07784cf 100644 --- a/mindspore/lite/src/ops/populate/v0/scale_populate_v0.cc +++ b/mindspore/lite/src/ops/populate/v0/scale_populate_v0.cc @@ -23,12 +23,13 @@ namespace lite { namespace { OpParameter *PopulateScaleParameter(const void *prim) { auto *primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); auto scale_prim = primitive->value_as_Scale(); - if (primitive == nullptr) { - MS_LOG(ERROR) << "input primitive is nullptr"; + if (scale_prim == nullptr) { + MS_LOG(ERROR) << "scale_prim is nullptr"; return nullptr; } - ScaleParameter *scale_param = reinterpret_cast(malloc(sizeof(ScaleParameter))); + auto *scale_param = reinterpret_cast(malloc(sizeof(ScaleParameter))); if (scale_param == nullptr) { MS_LOG(ERROR) << "malloc ScaleParameter failed."; return nullptr; diff --git a/mindspore/lite/src/ops/populate/v0/skip_gram_populate_v0.cc b/mindspore/lite/src/ops/populate/v0/skip_gram_populate_v0.cc index 5d8d7988a8..00d1ff787a 100644 --- a/mindspore/lite/src/ops/populate/v0/skip_gram_populate_v0.cc +++ b/mindspore/lite/src/ops/populate/v0/skip_gram_populate_v0.cc @@ -23,8 +23,13 @@ namespace lite { namespace { OpParameter *PopulateSkipGramParameter(const void *prim) { auto *primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); auto skip_gram_prim = primitive->value_as_SkipGram(); - SkipGramParameter *skipGramParameter = reinterpret_cast(malloc(sizeof(SkipGramParameter))); + if (skip_gram_prim == nullptr) { + MS_LOG(ERROR) << "skip_gram_prim is nullptr"; + return nullptr; + } + auto *skipGramParameter = reinterpret_cast(malloc(sizeof(SkipGramParameter))); if (skipGramParameter == nullptr) { MS_LOG(ERROR) << "malloc SkipGramParameter failed."; return nullptr; diff --git a/mindspore/lite/src/ops/populate/v0/slice_populate_v0.cc b/mindspore/lite/src/ops/populate/v0/slice_populate_v0.cc index 0d2742d211..d972dcd5be 100644 --- a/mindspore/lite/src/ops/populate/v0/slice_populate_v0.cc +++ b/mindspore/lite/src/ops/populate/v0/slice_populate_v0.cc @@ -23,8 +23,13 @@ namespace lite { namespace { OpParameter *PopulateSliceParameter(const void *prim) { auto *primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); auto slice_prim = primitive->value_as_Slice(); - SliceParameter *slice_param = reinterpret_cast(malloc(sizeof(SliceParameter))); + if (slice_prim == nullptr) { + MS_LOG(ERROR) << "slice_prim is nullptr"; + return nullptr; + } + auto *slice_param = reinterpret_cast(malloc(sizeof(SliceParameter))); if (slice_param == nullptr) { MS_LOG(ERROR) << "malloc SliceParameter failed."; return nullptr; @@ -35,6 +40,10 @@ OpParameter *PopulateSliceParameter(const void *prim) { auto param_begin = slice_prim->begin(); auto param_size = slice_prim->size(); auto param_axis = slice_prim->axes(); + if (param_begin == nullptr || param_size == nullptr || param_axis == nullptr) { + MS_LOG(ERROR) << "nullptr"; + return nullptr; + } if (param_begin->size() != param_size->size() || param_begin->size() != param_axis->size()) { free(slice_param); return nullptr; diff --git a/mindspore/lite/src/ops/populate/v0/softmax_populate_v0.cc b/mindspore/lite/src/ops/populate/v0/softmax_populate_v0.cc index 390ddaeb39..6add03009f 100644 --- a/mindspore/lite/src/ops/populate/v0/softmax_populate_v0.cc +++ b/mindspore/lite/src/ops/populate/v0/softmax_populate_v0.cc @@ -23,9 +23,13 @@ namespace lite { namespace { OpParameter *PopulateSoftmaxParameter(const void *prim) { auto *primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); auto softmax_prim = primitive->value_as_SoftMax(); - - SoftmaxParameter *softmax_param = reinterpret_cast(malloc(sizeof(SoftmaxParameter))); + if (softmax_prim == nullptr) { + MS_LOG(ERROR) << "softmax_prim is nullptr"; + return nullptr; + } + auto *softmax_param = reinterpret_cast(malloc(sizeof(SoftmaxParameter))); if (softmax_param == nullptr) { MS_LOG(ERROR) << "malloc SoftmaxParameter failed."; return nullptr; diff --git a/mindspore/lite/src/ops/populate/v0/space_to_batch_nd_populate_v0.cc b/mindspore/lite/src/ops/populate/v0/space_to_batch_nd_populate_v0.cc index 81bacedd49..9bd766d2bf 100644 --- a/mindspore/lite/src/ops/populate/v0/space_to_batch_nd_populate_v0.cc +++ b/mindspore/lite/src/ops/populate/v0/space_to_batch_nd_populate_v0.cc @@ -23,7 +23,12 @@ namespace lite { namespace { OpParameter *PopulateSpaceToBatchNDParameter(const void *prim) { auto *primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); auto space_to_batch_nd_prim = primitive->value_as_SpaceToBatchND(); + if (space_to_batch_nd_prim == nullptr) { + MS_LOG(ERROR) << "space_to_batch_nd_prim is nullptr"; + return nullptr; + } auto *space_batch_param_nd = reinterpret_cast(malloc(sizeof(SpaceToBatchParameter))); if (space_batch_param_nd == nullptr) { MS_LOG(ERROR) << "malloc SpaceToBatchParameter failed."; @@ -32,6 +37,10 @@ OpParameter *PopulateSpaceToBatchNDParameter(const void *prim) { space_batch_param_nd->op_parameter_.type_ = schema::PrimitiveType_SpaceToBatchND; auto block_sizes = space_to_batch_nd_prim->blockShape(); + if (block_sizes == nullptr) { + MS_LOG(ERROR) << "block_sizes is nullptr"; + return nullptr; + } space_batch_param_nd->m_ = block_sizes->size(); if (((size_t)block_sizes->size()) > std::numeric_limits::max() / sizeof(int)) { MS_LOG(ERROR) << "The value of block_sizes.size() is too big"; @@ -40,6 +49,10 @@ OpParameter *PopulateSpaceToBatchNDParameter(const void *prim) { } memcpy(space_batch_param_nd->block_sizes_, (block_sizes->data()), block_sizes->size() * sizeof(int)); auto paddings = space_to_batch_nd_prim->paddings(); + if (paddings == nullptr) { + MS_LOG(ERROR) << "paddings is nullptr"; + return nullptr; + } if (((size_t)paddings->size()) > std::numeric_limits::max() / sizeof(int)) { MS_LOG(ERROR) << "The value of paddings.size() is too big"; free(space_batch_param_nd); diff --git a/mindspore/lite/src/ops/populate/v0/space_to_batch_populate_v0.cc b/mindspore/lite/src/ops/populate/v0/space_to_batch_populate_v0.cc index c01154da13..9213f3a622 100644 --- a/mindspore/lite/src/ops/populate/v0/space_to_batch_populate_v0.cc +++ b/mindspore/lite/src/ops/populate/v0/space_to_batch_populate_v0.cc @@ -23,9 +23,13 @@ namespace lite { namespace { OpParameter *PopulateSpaceToBatchParameter(const void *prim) { auto *primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); auto space_to_batch_prim = primitive->value_as_SpaceToBatch(); - SpaceToBatchParameter *space_batch_param = - reinterpret_cast(malloc(sizeof(SpaceToBatchParameter))); + if (space_to_batch_prim == nullptr) { + MS_LOG(ERROR) << "space_to_batch_prim is nullptr"; + return nullptr; + } + auto *space_batch_param = reinterpret_cast(malloc(sizeof(SpaceToBatchParameter))); if (space_batch_param == nullptr) { MS_LOG(ERROR) << "malloc SpaceToBatchParameter failed."; return nullptr; @@ -33,6 +37,10 @@ OpParameter *PopulateSpaceToBatchParameter(const void *prim) { memset(space_batch_param, 0, sizeof(SpaceToBatchParameter)); space_batch_param->op_parameter_.type_ = schema::PrimitiveType_SpaceToBatch; auto block_sizes = space_to_batch_prim->blockShape(); // maybe error + if (block_sizes == nullptr) { + MS_LOG(ERROR) << "block_sizes is nullptr"; + return nullptr; + } space_batch_param->m_ = block_sizes->size(); if (((size_t)block_sizes->size()) > std::numeric_limits::max() / sizeof(int)) { MS_LOG(ERROR) << "The value of block_sizes.size() is too big"; @@ -41,6 +49,10 @@ OpParameter *PopulateSpaceToBatchParameter(const void *prim) { } memcpy(space_batch_param->block_sizes_, (block_sizes->data()), block_sizes->size() * sizeof(int)); auto paddings = space_to_batch_prim->paddings(); + if (paddings == nullptr) { + MS_LOG(ERROR) << "paddings is nullptr"; + return nullptr; + } if (((size_t)paddings->size()) > std::numeric_limits::max() / sizeof(int)) { MS_LOG(ERROR) << "The value of paddings.size() is too big"; free(space_batch_param); @@ -48,9 +60,9 @@ OpParameter *PopulateSpaceToBatchParameter(const void *prim) { } memcpy(space_batch_param->paddings_, (paddings->data()), paddings->size() * sizeof(int)); - space_batch_param->m_ = space_to_batch_prim->blockShape()->size(); + space_batch_param->m_ = block_sizes->size(); for (int i = 0; i < space_batch_param->m_; i++) { - space_batch_param->block_sizes_[i] = space_to_batch_prim->blockShape()->data()[i]; + space_batch_param->block_sizes_[i] = block_sizes->data()[i]; } return reinterpret_cast(space_batch_param); diff --git a/mindspore/lite/src/ops/populate/v0/space_to_depth_populate_v0.cc b/mindspore/lite/src/ops/populate/v0/space_to_depth_populate_v0.cc index 9306c97fc8..53dbaec9fe 100644 --- a/mindspore/lite/src/ops/populate/v0/space_to_depth_populate_v0.cc +++ b/mindspore/lite/src/ops/populate/v0/space_to_depth_populate_v0.cc @@ -23,9 +23,13 @@ namespace lite { namespace { OpParameter *PopulateSpaceToDepthParameter(const void *prim) { auto *primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); auto space_to_depth_prim = primitive->value_as_SpaceToDepth(); - SpaceToDepthParameter *space_depth_param = - reinterpret_cast(malloc(sizeof(SpaceToDepthParameter))); + if (space_to_depth_prim == nullptr) { + MS_LOG(ERROR) << "space_to_depth_prim is nullptr"; + return nullptr; + } + auto *space_depth_param = reinterpret_cast(malloc(sizeof(SpaceToDepthParameter))); if (space_depth_param == nullptr) { MS_LOG(ERROR) << "malloc SpaceToDepthParameter failed."; return nullptr; diff --git a/mindspore/lite/src/ops/populate/v0/split_populate_v0.cc b/mindspore/lite/src/ops/populate/v0/split_populate_v0.cc index aef06b9ebd..79cfeef7fd 100644 --- a/mindspore/lite/src/ops/populate/v0/split_populate_v0.cc +++ b/mindspore/lite/src/ops/populate/v0/split_populate_v0.cc @@ -23,7 +23,12 @@ namespace lite { namespace { OpParameter *PopulateSplitParameter(const void *prim) { auto *primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); auto split_prim = primitive->value_as_Split(); + if (split_prim == nullptr) { + MS_LOG(ERROR) << "split_prim is nullptr"; + return nullptr; + } auto *split_param = reinterpret_cast(malloc(sizeof(SplitParameter))); if (split_param == nullptr) { MS_LOG(ERROR) << "malloc SplitParameter failed."; @@ -46,7 +51,7 @@ OpParameter *PopulateSplitParameter(const void *prim) { memset(split_sizes, 0, split_param->num_split_ * sizeof(int)); split_param->split_sizes_ = split_sizes; auto split_sizes_vector_ = split_prim->sizeSplits(); - if (split_sizes_vector_ != NULL) { + if (split_sizes_vector_ != nullptr) { int i = 0; for (auto iter = split_sizes_vector_->begin(); iter != split_sizes_vector_->end(); iter++) { split_param->split_sizes_[i++] = *iter; diff --git a/mindspore/lite/src/ops/populate/v0/squared_difference_populate_v0.cc b/mindspore/lite/src/ops/populate/v0/squared_difference_populate_v0.cc index 6d50809c76..77430e9475 100644 --- a/mindspore/lite/src/ops/populate/v0/squared_difference_populate_v0.cc +++ b/mindspore/lite/src/ops/populate/v0/squared_difference_populate_v0.cc @@ -24,6 +24,7 @@ namespace lite { namespace { OpParameter *PopulateSquaredDifferenceParameter(const void *prim) { auto *primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); ArithmeticParameter *param = PopulateArithmeticV0CommonPara(primitive); if (param == nullptr) { MS_LOG(ERROR) << "PopulateArithmeticCommonPara failed."; diff --git a/mindspore/lite/src/ops/populate/v0/squeeze_populate_v0.cc b/mindspore/lite/src/ops/populate/v0/squeeze_populate_v0.cc index 154ff6bd7c..fa9df9cb98 100644 --- a/mindspore/lite/src/ops/populate/v0/squeeze_populate_v0.cc +++ b/mindspore/lite/src/ops/populate/v0/squeeze_populate_v0.cc @@ -23,18 +23,24 @@ namespace lite { namespace { OpParameter *PopulateSqueezeParameter(const void *prim) { auto *primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); auto squeeze_prim = primitive->value_as_Squeeze(); - SqueezeParameter *squeeze_param = reinterpret_cast(malloc(sizeof(SqueezeParameter))); + if (squeeze_prim == nullptr) { + MS_LOG(ERROR) << "squeeze_prim is nullptr"; + return nullptr; + } + auto *squeeze_param = reinterpret_cast(malloc(sizeof(SqueezeParameter))); if (squeeze_param == nullptr) { MS_LOG(ERROR) << "malloc SqueezeParameter failed."; return nullptr; } memset(squeeze_param, 0, sizeof(SqueezeParameter)); squeeze_param->op_parameter_.type_ = schema::PrimitiveType_Squeeze; - if (squeeze_prim->axis() != nullptr) { - squeeze_param->axis_size_ = squeeze_prim->axis()->size(); + auto axis = squeeze_prim->axis(); + if (axis != nullptr) { + squeeze_param->axis_size_ = axis->size(); for (size_t i = 0; i < squeeze_param->axis_size_; i++) { - squeeze_param->axis_[i] = *(squeeze_prim->axis()->begin() + i); + squeeze_param->axis_[i] = *(axis->begin() + i); } } else { squeeze_param->axis_size_ = 0; diff --git a/mindspore/lite/src/ops/populate/v0/stack_populate_v0.cc b/mindspore/lite/src/ops/populate/v0/stack_populate_v0.cc index 1c11ce9a3c..8e7a1e5e29 100644 --- a/mindspore/lite/src/ops/populate/v0/stack_populate_v0.cc +++ b/mindspore/lite/src/ops/populate/v0/stack_populate_v0.cc @@ -23,8 +23,13 @@ namespace lite { namespace { OpParameter *PopulateStackParameter(const void *prim) { auto *primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); auto stack_prim = primitive->value_as_Stack(); - StackParameter *stack_param = reinterpret_cast(malloc(sizeof(StackParameter))); + if (stack_prim == nullptr) { + MS_LOG(ERROR) << "stack_prim is nullptr"; + return nullptr; + } + auto *stack_param = reinterpret_cast(malloc(sizeof(StackParameter))); if (stack_param == nullptr) { MS_LOG(ERROR) << "malloc StackParameter failed."; return nullptr; diff --git a/mindspore/lite/src/ops/populate/v0/strided_slice_populate_v0.cc b/mindspore/lite/src/ops/populate/v0/strided_slice_populate_v0.cc index 933a5ce02c..f4ea9086f7 100644 --- a/mindspore/lite/src/ops/populate/v0/strided_slice_populate_v0.cc +++ b/mindspore/lite/src/ops/populate/v0/strided_slice_populate_v0.cc @@ -23,9 +23,13 @@ namespace mindspore { namespace lite { OpParameter *PopulateStridedSliceParameterV0(const void *prim) { auto *primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); auto strided_slice_prim = primitive->value_as_StridedSlice(); - StridedSliceParameter *strided_slice_param = - reinterpret_cast(malloc(sizeof(StridedSliceParameter))); + if (strided_slice_prim == nullptr) { + MS_LOG(ERROR) << "strided_slice_prim is nullptr"; + return nullptr; + } + auto *strided_slice_param = reinterpret_cast(malloc(sizeof(StridedSliceParameter))); if (strided_slice_param == nullptr) { MS_LOG(ERROR) << "malloc StridedSliceParameter failed."; return nullptr; diff --git a/mindspore/lite/src/ops/populate/v0/sub_populate_v0.cc b/mindspore/lite/src/ops/populate/v0/sub_populate_v0.cc index 8694f24641..0b97de5276 100644 --- a/mindspore/lite/src/ops/populate/v0/sub_populate_v0.cc +++ b/mindspore/lite/src/ops/populate/v0/sub_populate_v0.cc @@ -24,8 +24,13 @@ namespace lite { namespace { OpParameter *PopulateSubParameter(const void *prim) { auto *primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); auto sub_prim = primitive->value_as_Sub(); - ArithmeticParameter *param = PopulateArithmeticCommonPara(primitive); + if (sub_prim == nullptr) { + MS_LOG(ERROR) << "sub_prim is nullptr"; + return nullptr; + } + auto *param = PopulateArithmeticCommonPara(primitive); if (param == nullptr) { MS_LOG(ERROR) << "PopulateArithmeticCommonPara failed."; return nullptr; diff --git a/mindspore/lite/src/ops/populate/v0/tensorlistfromtensor_populate_v0.cc b/mindspore/lite/src/ops/populate/v0/tensorlistfromtensor_populate_v0.cc index b806fe45ee..8f75c03398 100644 --- a/mindspore/lite/src/ops/populate/v0/tensorlistfromtensor_populate_v0.cc +++ b/mindspore/lite/src/ops/populate/v0/tensorlistfromtensor_populate_v0.cc @@ -23,8 +23,13 @@ namespace lite { namespace { OpParameter *PopulateTensorListFromTensorParameter(const void *prim) { auto *primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); auto tensorList = primitive->value_as_TensorListFromTensor(); - TensorListParameter *TensorList_param = reinterpret_cast(malloc(sizeof(TensorListParameter))); + if (tensorList == nullptr) { + MS_LOG(ERROR) << "tensorList is nullptr"; + return nullptr; + } + auto *TensorList_param = reinterpret_cast(malloc(sizeof(TensorListParameter))); if (TensorList_param == nullptr) { MS_LOG(ERROR) << "malloc TensorListParameter failed."; return nullptr; diff --git a/mindspore/lite/src/ops/populate/v0/tensorlistgetitem_populate_v0.cc b/mindspore/lite/src/ops/populate/v0/tensorlistgetitem_populate_v0.cc index 7722fd50ef..529eae6f48 100644 --- a/mindspore/lite/src/ops/populate/v0/tensorlistgetitem_populate_v0.cc +++ b/mindspore/lite/src/ops/populate/v0/tensorlistgetitem_populate_v0.cc @@ -23,8 +23,13 @@ namespace lite { namespace { OpParameter *PopulateTensorListGetItemParameter(const void *prim) { auto *primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); auto tensorList_prim = primitive->value_as_TensorListGetItem(); - TensorListParameter *getItem_param = reinterpret_cast(malloc(sizeof(TensorListParameter))); + if (tensorList_prim == nullptr) { + MS_LOG(ERROR) << "tensorList_prim is nullptr"; + return nullptr; + } + auto *getItem_param = reinterpret_cast(malloc(sizeof(TensorListParameter))); if (getItem_param == nullptr) { MS_LOG(ERROR) << "malloc TensorListParameter failed."; return nullptr; diff --git a/mindspore/lite/src/ops/populate/v0/tensorlistreserve_populate_v0.cc b/mindspore/lite/src/ops/populate/v0/tensorlistreserve_populate_v0.cc index bc311f0f74..6902d90758 100644 --- a/mindspore/lite/src/ops/populate/v0/tensorlistreserve_populate_v0.cc +++ b/mindspore/lite/src/ops/populate/v0/tensorlistreserve_populate_v0.cc @@ -23,8 +23,13 @@ namespace lite { namespace { OpParameter *PopulateTensorListReserveParameter(const void *prim) { auto *primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); auto tensorList_prim = primitive->value_as_TensorListReserve(); - TensorListParameter *reserve_param = reinterpret_cast(malloc(sizeof(TensorListParameter))); + if (tensorList_prim == nullptr) { + MS_LOG(ERROR) << "tensorList_prim is nullptr"; + return nullptr; + } + auto *reserve_param = reinterpret_cast(malloc(sizeof(TensorListParameter))); if (reserve_param == nullptr) { MS_LOG(ERROR) << "malloc TensorListParameter failed."; return nullptr; diff --git a/mindspore/lite/src/ops/populate/v0/tensorlistsetlitem_populate_v0.cc b/mindspore/lite/src/ops/populate/v0/tensorlistsetlitem_populate_v0.cc index 7f947aae1b..ff7a2252ee 100644 --- a/mindspore/lite/src/ops/populate/v0/tensorlistsetlitem_populate_v0.cc +++ b/mindspore/lite/src/ops/populate/v0/tensorlistsetlitem_populate_v0.cc @@ -23,8 +23,13 @@ namespace lite { namespace { OpParameter *PopulateTensorListSetItemParameter(const void *prim) { auto *primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); auto tensorList_prim = primitive->value_as_TensorListSetItem(); - TensorListParameter *setItem_param = reinterpret_cast(malloc(sizeof(TensorListParameter))); + if (tensorList_prim == nullptr) { + MS_LOG(ERROR) << "tensorList_prim is nullptr"; + return nullptr; + } + auto *setItem_param = reinterpret_cast(malloc(sizeof(TensorListParameter))); if (setItem_param == nullptr) { MS_LOG(ERROR) << "malloc TensorListParameter failed."; return nullptr; diff --git a/mindspore/lite/src/ops/populate/v0/tensorliststack_populate_v0.cc b/mindspore/lite/src/ops/populate/v0/tensorliststack_populate_v0.cc index cf5495efa4..c6d600e5b1 100644 --- a/mindspore/lite/src/ops/populate/v0/tensorliststack_populate_v0.cc +++ b/mindspore/lite/src/ops/populate/v0/tensorliststack_populate_v0.cc @@ -23,8 +23,13 @@ namespace lite { namespace { OpParameter *PopulateTensorListStackParameter(const void *prim) { auto *primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); auto tensorList_prim = primitive->value_as_TensorListStack(); - TensorListParameter *stack_param = reinterpret_cast(malloc(sizeof(TensorListParameter))); + if (tensorList_prim == nullptr) { + MS_LOG(ERROR) << "tensorList_prim is nullptr"; + return nullptr; + } + auto *stack_param = reinterpret_cast(malloc(sizeof(TensorListParameter))); if (stack_param == nullptr) { MS_LOG(ERROR) << "malloc TensorListParameter failed."; return nullptr; diff --git a/mindspore/lite/src/ops/populate/v0/tile_populate_v0.cc b/mindspore/lite/src/ops/populate/v0/tile_populate_v0.cc index 1fba50856f..991c479324 100644 --- a/mindspore/lite/src/ops/populate/v0/tile_populate_v0.cc +++ b/mindspore/lite/src/ops/populate/v0/tile_populate_v0.cc @@ -23,8 +23,13 @@ namespace lite { namespace { OpParameter *PopulateTileParameter(const void *prim) { auto *primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); auto tile_prim = primitive->value_as_Tile(); - TileParameter *tile_param = reinterpret_cast(malloc(sizeof(TileParameter))); + if (tile_prim == nullptr) { + MS_LOG(ERROR) << "tile_prim is nullptr"; + return nullptr; + } + auto *tile_param = reinterpret_cast(malloc(sizeof(TileParameter))); if (tile_param == nullptr) { MS_LOG(ERROR) << "malloc TileParameter failed."; return nullptr; @@ -45,7 +50,7 @@ OpParameter *PopulateTileParameter(const void *prim) { tile_param->dims_[i] = static_cast(dims->Get(i)); } } - tile_param->dims_size_ = tile_prim->dims()->size(); + tile_param->dims_size_ = dims->size(); } #endif diff --git a/mindspore/lite/src/ops/populate/v0/topk_populate_v0.cc b/mindspore/lite/src/ops/populate/v0/topk_populate_v0.cc index f87f03e590..ebcd81fadd 100644 --- a/mindspore/lite/src/ops/populate/v0/topk_populate_v0.cc +++ b/mindspore/lite/src/ops/populate/v0/topk_populate_v0.cc @@ -23,8 +23,13 @@ namespace lite { namespace { OpParameter *PopulateTopKParameter(const void *prim) { auto *primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); auto topk_prim = primitive->value_as_TopK(); - TopkParameter *topk_param = reinterpret_cast(malloc(sizeof(TopkParameter))); + if (topk_prim == nullptr) { + MS_LOG(ERROR) << "topk_prim is nullptr"; + return nullptr; + } + auto *topk_param = reinterpret_cast(malloc(sizeof(TopkParameter))); if (topk_param == nullptr) { MS_LOG(ERROR) << "malloc TopkParameter failed."; return nullptr; diff --git a/mindspore/lite/src/ops/populate/v0/transpose_populate_v0.cc b/mindspore/lite/src/ops/populate/v0/transpose_populate_v0.cc index defa29b26c..8ae25c763e 100644 --- a/mindspore/lite/src/ops/populate/v0/transpose_populate_v0.cc +++ b/mindspore/lite/src/ops/populate/v0/transpose_populate_v0.cc @@ -23,8 +23,13 @@ namespace lite { namespace { OpParameter *PopulateTransposeParameter(const void *prim) { auto *primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); auto transpose_prim = primitive->value_as_Transpose(); - TransposeParameter *transpose_param = reinterpret_cast(malloc(sizeof(TransposeParameter))); + if (transpose_prim == nullptr) { + MS_LOG(ERROR) << "transpose_prim is nullptr"; + return nullptr; + } + auto *transpose_param = reinterpret_cast(malloc(sizeof(TransposeParameter))); if (transpose_param == nullptr) { MS_LOG(ERROR) << "malloc TransposeParameter failed."; return nullptr; @@ -33,12 +38,16 @@ OpParameter *PopulateTransposeParameter(const void *prim) { transpose_param->op_parameter_.type_ = schema::PrimitiveType_Transpose; auto perm_vector_ = transpose_prim->perm(); + if (perm_vector_ == nullptr) { + MS_LOG(ERROR) << "perm_vector_ is nullptr"; + return nullptr; + } int i = 0; for (auto iter = perm_vector_->begin(); iter != perm_vector_->end(); iter++) { transpose_param->perm_[i++] = *iter; } transpose_param->num_axes_ = i; - transpose_param->perm_size_ = transpose_prim->perm()->size(); + transpose_param->perm_size_ = perm_vector_->size(); return reinterpret_cast(transpose_param); } diff --git a/mindspore/lite/src/ops/populate/v0/unsqueeze_populate_v0.cc b/mindspore/lite/src/ops/populate/v0/unsqueeze_populate_v0.cc index 93ea17f0c6..4f880bbeaa 100644 --- a/mindspore/lite/src/ops/populate/v0/unsqueeze_populate_v0.cc +++ b/mindspore/lite/src/ops/populate/v0/unsqueeze_populate_v0.cc @@ -23,9 +23,13 @@ namespace lite { namespace { OpParameter *PopulateUnsqueezeParameter(const void *prim) { auto *primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); auto unsqueeze_prim = primitive->value_as_Unsqueeze(); - - UnSqueezeParameter *unsqueeze_param = reinterpret_cast(malloc(sizeof(UnSqueezeParameter))); + if (unsqueeze_prim == nullptr) { + MS_LOG(ERROR) << "unsqueeze_prim is nullptr"; + return nullptr; + } + auto *unsqueeze_param = reinterpret_cast(malloc(sizeof(UnSqueezeParameter))); if (unsqueeze_param == nullptr) { MS_LOG(ERROR) << "malloc UnSqueezeParameter failed."; return nullptr; @@ -33,6 +37,10 @@ OpParameter *PopulateUnsqueezeParameter(const void *prim) { memset(unsqueeze_param, 0, sizeof(UnSqueezeParameter)); unsqueeze_param->op_parameter_.type_ = schema::PrimitiveType_Unsqueeze; auto flatAxis = unsqueeze_prim->axis(); + if (flatAxis == nullptr) { + MS_LOG(ERROR) << "flatAxis is nullptr"; + return nullptr; + } unsqueeze_param->num_dim_ = flatAxis->size(); int i = 0; for (auto iter = flatAxis->begin(); iter != flatAxis->end(); iter++) { diff --git a/mindspore/lite/src/ops/populate/v0/unstack_populate_v0.cc b/mindspore/lite/src/ops/populate/v0/unstack_populate_v0.cc index 80dbfa3254..5959c11b93 100644 --- a/mindspore/lite/src/ops/populate/v0/unstack_populate_v0.cc +++ b/mindspore/lite/src/ops/populate/v0/unstack_populate_v0.cc @@ -23,8 +23,13 @@ namespace lite { namespace { OpParameter *PopulateUnstackParameter(const void *prim) { auto *primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); auto unstack_prim = primitive->value_as_Unstack(); - UnstackParameter *unstack_param = reinterpret_cast(malloc(sizeof(UnstackParameter))); + if (unstack_prim == nullptr) { + MS_LOG(ERROR) << "unstack_prim is nullptr"; + return nullptr; + } + auto *unstack_param = reinterpret_cast(malloc(sizeof(UnstackParameter))); if (unstack_param == nullptr) { MS_LOG(ERROR) << "malloc UnstackParameter failed."; return nullptr; diff --git a/mindspore/lite/src/ops/populate/v0/while_populate_v0.cc b/mindspore/lite/src/ops/populate/v0/while_populate_v0.cc index 0231f800bf..b7e4ba012b 100644 --- a/mindspore/lite/src/ops/populate/v0/while_populate_v0.cc +++ b/mindspore/lite/src/ops/populate/v0/while_populate_v0.cc @@ -28,8 +28,13 @@ typedef struct WhileParemeter { OpParameter *PopulateWhileParameter(const void *prim) { auto *primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); auto while_prim = primitive->value_as_While(); - WhileParemeter *while_paremeter = reinterpret_cast(malloc(sizeof(WhileParemeter))); + if (while_prim == nullptr) { + MS_LOG(ERROR) << "while_prim is nullptr"; + return nullptr; + } + auto *while_paremeter = reinterpret_cast(malloc(sizeof(WhileParemeter))); if (while_paremeter == nullptr) { MS_LOG(ERROR) << "malloc WhileParemeter failed."; return nullptr; diff --git a/mindspore/lite/src/ops/populate/where_populate.cc b/mindspore/lite/src/ops/populate/where_populate.cc index 2aed0429bf..08903b248c 100644 --- a/mindspore/lite/src/ops/populate/where_populate.cc +++ b/mindspore/lite/src/ops/populate/where_populate.cc @@ -21,13 +21,14 @@ namespace mindspore { namespace lite { namespace { OpParameter *PopulateWhereParameter(const void *prim) { - WhereParameter *where_parameter = reinterpret_cast(malloc(sizeof(WhereParameter))); + auto *where_parameter = reinterpret_cast(malloc(sizeof(WhereParameter))); if (where_parameter == nullptr) { MS_LOG(ERROR) << "malloc Where parameter failed."; return nullptr; } memset(where_parameter, 0, sizeof(OpParameter)); auto primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); where_parameter->op_parameter_.type_ = primitive->value_type(); return reinterpret_cast(where_parameter); } diff --git a/mindspore/lite/src/ops/populate/while_populate.cc b/mindspore/lite/src/ops/populate/while_populate.cc index 7756ecea8a..632748f248 100644 --- a/mindspore/lite/src/ops/populate/while_populate.cc +++ b/mindspore/lite/src/ops/populate/while_populate.cc @@ -26,14 +26,19 @@ typedef struct WhileParemeter { } WhileParemeter; OpParameter *PopulateWhileParemeter(const void *prim) { - WhileParemeter *while_paremeter = reinterpret_cast(malloc(sizeof(WhileParemeter))); + auto *while_paremeter = reinterpret_cast(malloc(sizeof(WhileParemeter))); if (while_paremeter == nullptr) { MS_LOG(ERROR) << "malloc WhileParemeter failed."; return nullptr; } memset(while_paremeter, 0, sizeof(WhileParemeter)); auto primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); auto value = primitive->value_as_While(); + if (value == nullptr) { + MS_LOG(ERROR) << "value is nullptr"; + return nullptr; + } while_paremeter->op_parameter_.type_ = primitive->value_type(); while_paremeter->body_subgraph_index = value->body_subgraph_index(); while_paremeter->cond_subgraph_index = value->cond_subgraph_index(); diff --git a/mindspore/lite/tools/converter/converter.cc b/mindspore/lite/tools/converter/converter.cc index 9dc2a32f6e..0ea76a11ac 100644 --- a/mindspore/lite/tools/converter/converter.cc +++ b/mindspore/lite/tools/converter/converter.cc @@ -52,7 +52,7 @@ std::unique_ptr Converter::CreateConverter(converter::FmkType fmk) { } } -MetaGraphT *Converter::Convert(const std::unique_ptr &flag) { +schema::MetaGraphT *Converter::Convert(const std::unique_ptr &flag) { if (flag == nullptr) { MS_LOG(ERROR) << "Input flag is nullptr"; return nullptr; @@ -62,13 +62,13 @@ MetaGraphT *Converter::Convert(const std::unique_ptr &flag) { MS_LOG(ERROR) << "Parser/Import model return nullptr"; return nullptr; } + // funcgraph compile graph = funcgraph_transform_->Transform(graph, flag.get()); if (graph == nullptr) { MS_LOG(ERROR) << "Transform anf graph return nullptr"; return nullptr; } - MS_LOG(INFO) << "Run anfTransform success"; // protobuf -> flatbuf auto meta_graph = Export(graph, false, false, flag->trainModel); @@ -76,7 +76,6 @@ MetaGraphT *Converter::Convert(const std::unique_ptr &flag) { MS_LOG(ERROR) << "Export to meta graph return nullptr"; return nullptr; } - MS_LOG(INFO) << "export success"; // metagraph compile metagraph_transform_->SetGraphDef(meta_graph);