!17792 fix codex

Merge pull request !17792 from zhujingxuan/master

mindspore/lite/micro/coder/opcoders/base/detection_post_process_base_coder.cc

@@ -59,10 +59,10 @@ int DetectionPostProcessBaseCoder::Prepare(CoderContext *const context) {
                             anchor_tensor->ElementsNum());
     params_->anchors_ = anchor_fp32;
   } else if (anchor_tensor->data_type() == kNumberTypeFloat32 || anchor_tensor->data_type() == kNumberTypeFloat) {
-    params_->anchors_ = static_cast<float *>(
-      allocator_->Malloc(kNumberTypeFloat, anchor_tensor->ElementsNum() * sizeof(float), kOfflinePackWeight));
+    params_->anchors_ =
+      static_cast<float *>(allocator_->Malloc(kNumberTypeFloat, anchor_tensor->Size(), kOfflinePackWeight));
     MS_CHECK_PTR(params_->anchors_);
-    memcpy(params_->anchors_, anchor_tensor->data_c(), anchor_tensor->Size());
+    memcpy_s(params_->anchors_, anchor_tensor->Size(), anchor_tensor->data_c(), anchor_tensor->Size());
   } else {
     MS_LOG(ERROR) << "unsupported anchor data type " << anchor_tensor->data_type();
     return RET_ERROR;

mindspore/lite/micro/coder/opcoders/nnacl/fp32/arithmetic_fp32_coder.cc

@@ -517,5 +517,4 @@ REG_OPERATOR_CODER(kAllTargets, kNumberTypeFloat32, PrimitiveType_Greater, CPUOp
 REG_OPERATOR_CODER(kAllTargets, kNumberTypeFloat32, PrimitiveType_GreaterEqual, CPUOpCoderCreator<ArithmeticFP32Coder>)
 
 REG_OPERATOR_CODER(kAllTargets, kNumberTypeFloat32, PrimitiveType_Eltwise, CPUOpCoderCreator<ArithmeticFP32Coder>)
-
 }  // namespace mindspore::lite::micro::nnacl

mindspore/lite/micro/coder/opcoders/nnacl/fp32/pooling_fp32_coder.cc

@@ -45,54 +45,31 @@ int PoolingFP32Coder::DoCode(CoderContext *const context) {
   code.CodeStruct("pooling_parameter", *pooling_parameter);
   float minf = -FLT_MAX;
   float maxf = FLT_MAX;
-  if (pooling_parameter->pool_mode_ == PoolMode_MaxPool) {
-    Collect(context,
-            {
-              "nnacl/fp32/pooling_fp32.h",
-            },
-            {
-              "pooling_fp32.c",
-            });
-    switch (pooling_parameter->act_type_) {
-      case ActType_Relu: {
-        minf = 0.f;
-        break;
-      }
-      case ActType_Relu6: {
-        minf = 0.f;
-        maxf = 6.f;
-        break;
-      }
-      default: {
-        MS_LOG(INFO) << "no actype";
-        break;
-      }
+  Collect(context,
+          {
+            "nnacl/fp32/pooling_fp32.h",
+          },
+          {
+            "pooling_fp32.c",
+          });
+  switch (pooling_parameter->act_type_) {
+    case ActType_Relu: {
+      minf = 0.f;
+      break;
     }
-
+    case ActType_Relu6: {
+      minf = 0.f;
+      maxf = 6.f;
+      break;
+    }
+    default: {
+      MS_LOG(INFO) << "no actype";
+      break;
+    }
+  }
+  if (pooling_parameter->pool_mode_ == PoolMode_MaxPool) {
     code.CodeFunction("MaxPooling", input_tensor_, output_tensor_, "&pooling_parameter", kDefaultTaskId, minf, maxf);
   } else {
-    Collect(context,
-            {
-              "nnacl/fp32/pooling_fp32.h",
-            },
-            {
-              "pooling_fp32.c",
-            });
-    switch (pooling_parameter->act_type_) {
-      case ActType_Relu: {
-        minf = 0.f;
-        break;
-      }
-      case ActType_Relu6: {
-        minf = 0.f;
-        maxf = 6.f;
-        break;
-      }
-      default: {
-        MS_LOG(INFO) << "no actype";
-        break;
-      }
-    }
     code.CodeFunction("AvgPooling", input_tensor_, output_tensor_, "&pooling_parameter", kDefaultTaskId, minf, maxf);
   }
 

mindspore/lite/micro/coder/opcoders/nnacl/int8/concat_int8_coder.cc

@@ -75,8 +75,8 @@ int ConcatInt8Coder::Prepare(CoderContext *const context) {
   int output_dim = static_cast<int>(output_tensor_->shape().size());
   concat_param_->output_shapes_ = reinterpret_cast<int *>(malloc(output_dim * sizeof(int)));
   MS_CHECK_PTR(concat_param_->output_shapes_);
-  memcpy(reinterpret_cast<void *>(concat_param_->output_shapes_), output_tensor_->shape().data(),
-         sizeof(int) * output_dim);
+  memcpy_s(reinterpret_cast<void *>(concat_param_->output_shapes_), output_dim * sizeof(int),
+           output_tensor_->shape().data(), sizeof(int) * output_dim);
   for (int i = axis_ + 1; i < output_dim; i++) {
     after_axis_size *= concat_param_->output_shapes_[i];
   }

mindspore/lite/micro/coder/opcoders/nnacl/int8/conv2d_1x1_int8_coder.cc

@@ -152,7 +152,8 @@ int Conv2D1x1Int8Coder::InitWeightBias(CoderContext *const context) {
   int32_t input_channel = filter_tensor_->Channel();
   int32_t output_channel = filter_tensor_->Batch();
   int32_t input_zp = conv_param_->conv_quant_arg_.input_quant_args_[0].zp_;
-
+  MS_CHECK_TRUE(input_channel > 0, "input_channel should be positive");
+  MS_CHECK_TRUE(output_channel > 0, "output_channel should be positive");
   nnacl::NNaclInt8Serializer code;
 
   packed_weight_ = static_cast<int8_t *>(allocator_->Malloc(kNumberTypeInt8, kOnlineSize, kOnlinePackWeight));

mindspore/lite/micro/coder/opcoders/nnacl/int8/sigmoid_int8_coder.cc

@@ -23,13 +23,13 @@
 #include "coder/opcoders/serializers/nnacl_serializer/nnacl_int8_serializer.h"
 
 namespace mindspore::lite::micro::nnacl {
-constexpr auto int8_range = 256;
+constexpr auto kInt8Range = 256;
 
 void CalculateTableList(int8_t *table, const float input_scale, const int32_t input_zp) {
-  int32_t min_value = std::numeric_limits<int8_t>::min();
-  int32_t max_value = std::numeric_limits<int8_t>::max();
-  const float output_scale = 1.0f / int8_range;
-  const int32_t output_zp = -128;
+  constexpr int32_t min_value = std::numeric_limits<int8_t>::min();
+  constexpr int32_t max_value = std::numeric_limits<int8_t>::max();
+  constexpr float output_scale = 1.0f / kInt8Range;
+  constexpr int32_t output_zp = std::numeric_limits<int8_t>::min();
 
   for (int i = min_value; i < max_value; ++i) {
     const float real_input_value = input_scale * (i - input_zp);
@@ -42,15 +42,15 @@ void CalculateTableList(int8_t *table, const float input_scale, const int32_t in
 }
 
 int SigmodInt8Coder::Prepare(CoderContext *const context) {
-  table_list_ = static_cast<int8_t *>(allocator_->Malloc(kNumberTypeInt8, int8_range, kOfflinePackWeight));
+  table_list_ = static_cast<int8_t *>(allocator_->Malloc(kNumberTypeInt8, kInt8Range, kOfflinePackWeight));
   MS_CHECK_PTR(table_list_);
 
   const float input_scale = input_tensor_->quant_params().at(0).scale;
   const int32_t input_zp = input_tensor_->quant_params().at(0).zeroPoint;
   const float output_scale = output_tensor_->quant_params().at(0).scale;
   const int32_t output_zp = output_tensor_->quant_params().at(0).zeroPoint;
-  if (output_scale != (1.0f / int8_range) || output_zp != -128) {
-    MS_LOG(ERROR) << "Output scale is : " << output_scale << ", should be 1/int8_range. Output zp is : " << output_zp
+  if (output_scale != (1.0f / kInt8Range) || output_zp != static_cast<int32_t>(std::numeric_limits<int8_t>::min())) {
+    MS_LOG(ERROR) << "Output scale is : " << output_scale << ", should be 1/kInt8Range. Output zp is : " << output_zp
                   << ", should be -128.";
     return RET_ERROR;
   }