!7996 [lite] fix cppcheck

Merge pull request !7996 from 徐安越/master

mindspore/lite/src/model_common.cc

@@ -90,6 +90,10 @@ Model *ImportFromBuffer(const char *model_buf, size_t size, bool take_buf) {
   if (take_buf) {
     model->buf = const_cast<char *>(model_buf);
   } else {
+    if (size == 0) {
+      MS_LOG(ERROR) << "malloc size is equal to 0";
+      return nullptr;
+    }
     model->buf = reinterpret_cast<char *>(malloc(size));
     if (model->buf == nullptr) {
       MS_LOG(ERROR) << "new inner model buf fail!";

mindspore/lite/src/runtime/workspace_pool.cc

@@ -112,7 +112,7 @@ void *WorkspacePool::AllocWorkSpaceMem(size_t size) {
   return alloc.second;
 }
 
-void WorkspacePool::FreeWorkSpaceMem(void *ptr) {
+void WorkspacePool::FreeWorkSpaceMem(const void *ptr) {
   if (ptr == nullptr) {
     return;
   }

mindspore/lite/src/runtime/workspace_pool.h

@@ -33,7 +33,7 @@ class WorkspacePool {
   WorkspacePool &operator=(const WorkspacePool &) = delete;
   static WorkspacePool *GetInstance();
   void *AllocWorkSpaceMem(size_t size);
-  void FreeWorkSpaceMem(void *ptr);
+  void FreeWorkSpaceMem(const void *ptr);
 
  private:
   std::vector<std::pair<size_t, void *>> allocList{};

mindspore/lite/src/scheduler.h

@@ -27,6 +27,7 @@ namespace mindspore::lite {
 class Scheduler {
  public:
   explicit Scheduler(const InnerContext *ctx) { context_ = const_cast<InnerContext *>(ctx); }
+  ~Scheduler() = default;
 
   int Schedule(const lite::Model *model, std::vector<Tensor *> *tensors, std::vector<kernel::LiteKernel *> *kernels);
 

mindspore/lite/src/sub_graph_kernel.cc

@@ -199,12 +199,22 @@ int CpuFp16SubGraph::PostProcess() {
       auto ret = tensor->FreeData();
       if (RET_OK != ret) {
         MS_LOG(ERROR) << "free data failed";
+        if (this->context_ != nullptr && this->context_->allocator != nullptr) {
+          this->context_->allocator->Free(float16_data);
+        } else {
+          free(float16_data);
+        }
         return RET_ERROR;
       }
       tensor->set_data_type(TypeId::kNumberTypeFloat32);
       ret = tensor->MallocData();
       if (RET_OK != ret) {
         MS_LOG(ERROR) << "malloc data failed";
+        if (this->context_ != nullptr && this->context_->allocator != nullptr) {
+          this->context_->allocator->Free(float16_data);
+        } else {
+          free(float16_data);
+        }
         return RET_ERROR;
       }
       fp16_to_fp32_cast_func(float16_data, tensor->data_c(), tensor->ElementsNum());

mindspore/lite/tools/benchmark/benchmark.cc

@@ -427,7 +427,9 @@ int Benchmark::RunBenchmark() {
       return ret;
     }
   }
-  model->Free();
+  if (model != nullptr) {
+    model->Free();
+  }
   ms_inputs_ = session_->GetInputs();
   auto end_prepare_time = GetTimeUs();
   MS_LOG(INFO) << "PrepareTime = " << (end_prepare_time - start_prepare_time) / 1000 << " ms";
@@ -446,6 +448,7 @@ int Benchmark::RunBenchmark() {
       data.second->shape.clear();
       data.second->data.clear();
       delete data.second;
+      data.second = nullptr;
     }
     benchmark_data_.clear();
     if (status != 0) {

mindspore/lite/tools/converter/legacy_optimizer/graph/format_trans_pass.cc

@@ -137,7 +137,7 @@ STATUS FormatTransPass::DoNodeInoutFormatTrans(schema::MetaGraphT *graph) {
       MS_LOG(ERROR) << "Op should have " << kOutputNum << " output tensor";
       return RET_ERROR;
     }
-    STATUS status;
+    STATUS status = RET_OK;
 #ifdef SUPPORT_TRAIN
     if (IsContain(GetNhwcAllInputOpList(), GetCNodeTType(**iter))) {
       int idx_num = node->inputIndex.size();

mindspore/lite/tools/converter/legacy_optimizer/graph/trans_format_insert_pass.cc

@@ -143,6 +143,7 @@ STATUS TransOpInsertPass::ChangeOpAxis(schema::MetaGraphT *graph, const std::uni
   if (type == PrimitiveType_Concat) {
     auto origin_axis = node->primitive->value.AsConcat()->axis;
     auto axis_map = GetNc2NhAxisMap();
+    MS_ASSERT(node->primitive->value.AsConcat() != nullptr);
     node->primitive->value.AsConcat()->axis = axis_map[origin_axis];
   }
   if (type == PrimitiveType_StridedSlice) {
@@ -157,12 +158,14 @@ STATUS TransOpInsertPass::ChangeOpAxis(schema::MetaGraphT *graph, const std::uni
   if (type == PrimitiveType_Split) {
     auto origin_axis = node->primitive->value.AsSplit()->splitDim;
     auto axis_map = GetNc2NhAxisMap();
+    MS_ASSERT(node->primitive->value.AsSplit != nullptr);
     node->primitive->value.AsSplit()->splitDim = axis_map[origin_axis];
   }
   if (type == PrimitiveType_Crop) {
     auto origin_axis = node->primitive->value.AsCrop()->axis;
     auto offsets = node->primitive->value.AsCrop()->offsets;
     auto axis_map = GetNc2NhAxisMap();
+    MS_ASSERT(node->primitive->value.AsCrop() != nullptr);
     node->primitive->value.AsCrop()->axis = axis_map[origin_axis];
     // nchw->nhwc,offsets need pad 0;
     if (axis_map[origin_axis] == 0) {
@@ -178,10 +181,15 @@ STATUS TransOpInsertPass::ChangeOpAxis(schema::MetaGraphT *graph, const std::uni
       MS_LOG(ERROR) << "Crop error";
       return RET_ERROR;
     }
+    MS_ASSERT(node->primitive->value.AsCrop() != nullptr);
     node->primitive->value.AsCrop()->offsets = offsets;
   }
   if (type == PrimitiveType_Slice) {
     auto attr = node->primitive->value.AsSlice();
+    if (attr == nullptr) {
+      MS_LOG(ERROR) << "attr is nullptr";
+      return RET_NULL_PTR;
+    }
     auto origin_begin = attr->begin;
     attr->begin = {origin_begin[NCHW_N], origin_begin[NCHW_H], origin_begin[NCHW_W], origin_begin[NCHW_C]};
     auto origin_end = attr->axes;

mindspore/lite/tools/converter/parser/caffe/caffe_argmax_parser.h

@@ -26,7 +26,7 @@ namespace lite {
 class CaffeArgMaxParser : public CaffeNodeParser {
  public:
   CaffeArgMaxParser() : CaffeNodeParser("argmax") {}
-
+  ~CaffeArgMaxParser() = default;
   STATUS Parse(const caffe::LayerParameter &proto, const caffe::LayerParameter &weight, schema::CNodeT *op,
                std::vector<schema::TensorT *> *weightVec) override;
 };

mindspore/lite/tools/converter/parser/caffe/caffe_concat_parser.h

@@ -26,6 +26,7 @@ namespace lite {
 class CaffeConcatParser : public CaffeNodeParser {
  public:
   CaffeConcatParser() : CaffeNodeParser("concat") {}
+  ~CaffeConcatParser() = default;
 
   STATUS Parse(const caffe::LayerParameter &proto, const caffe::LayerParameter &weight, schema::CNodeT *op,
                std::vector<schema::TensorT *> *weightVec) override;

mindspore/lite/tools/converter/parser/caffe/caffe_convolution_parser.h

@@ -27,6 +27,7 @@ namespace lite {
 class CaffeConvolutionParser : public CaffeNodeParser {
  public:
   CaffeConvolutionParser() : CaffeNodeParser("convolution") {}
+  ~CaffeConvolutionParser() = default;
 
   STATUS Parse(const caffe::LayerParameter &proto, const caffe::LayerParameter &weight, schema::CNodeT *op,
                std::vector<schema::TensorT *> *weightVec) override;

mindspore/lite/tools/converter/parser/caffe/caffe_crop_parser.h

@@ -26,6 +26,7 @@ namespace lite {
 class CaffeCropParser : public CaffeNodeParser {
  public:
   CaffeCropParser() : CaffeNodeParser("crop") {}
+  ~CaffeCropParser() = default;
 
   STATUS Parse(const caffe::LayerParameter &proto, const caffe::LayerParameter &weight, schema::CNodeT *op,
                std::vector<schema::TensorT *> *weightVec) override;

mindspore/lite/tools/converter/parser/caffe/caffe_deconvolution_parser.h

@@ -27,6 +27,7 @@ namespace lite {
 class CaffeDeconvolutionParser : public CaffeNodeParser {
  public:
   CaffeDeconvolutionParser() : CaffeNodeParser("deconvolution") {}
+  ~CaffeDeconvolutionParser() = default;
 
   STATUS Parse(const caffe::LayerParameter &proto, const caffe::LayerParameter &weight, schema::CNodeT *op,
                std::vector<schema::TensorT *> *weightVec) override;

mindspore/lite/tools/converter/parser/caffe/caffe_eltwise_parser.h

@@ -26,6 +26,7 @@ namespace lite {
 class CaffeEltwiseParser : public CaffeNodeParser {
  public:
   CaffeEltwiseParser() : CaffeNodeParser("eltwise") {}
+  ~CaffeEltwiseParser() = default;
 
   STATUS Parse(const caffe::LayerParameter &proto, const caffe::LayerParameter &weight, schema::CNodeT *op,
                std::vector<schema::TensorT *> *weightVec) override;

mindspore/lite/tools/converter/parser/caffe/caffe_elu_parser.h

@@ -26,6 +26,7 @@ namespace lite {
 class CaffeEluParser : public CaffeNodeParser {
  public:
   CaffeEluParser() : CaffeNodeParser("elu") {}
+  ~CaffeEluParser() = default;
 
   STATUS Parse(const caffe::LayerParameter &proto, const caffe::LayerParameter &weight, schema::CNodeT *op,
                std::vector<schema::TensorT *> *weightVec) override;

mindspore/lite/tools/converter/parser/caffe/caffe_exp_parser.h

@@ -26,6 +26,7 @@ namespace lite {
 class CaffeExpParser : public CaffeNodeParser {
  public:
   CaffeExpParser() : CaffeNodeParser("exp") {}
+  ~CaffeExpParser() = default;
 
   STATUS Parse(const caffe::LayerParameter &proto, const caffe::LayerParameter &weight, schema::CNodeT *op,
                std::vector<schema::TensorT *> *weightVec) override;

mindspore/lite/tools/converter/parser/caffe/caffe_flatten_parser.h

@@ -26,6 +26,7 @@ namespace lite {
 class CaffeFlattenParser : public CaffeNodeParser {
  public:
   CaffeFlattenParser() : CaffeNodeParser("flatten") {}
+  ~CaffeFlattenParser() = default;
 
   STATUS Parse(const caffe::LayerParameter &proto, const caffe::LayerParameter &weight, schema::CNodeT *op,
                std::vector<schema::TensorT *> *weightVec) override;

mindspore/lite/tools/converter/parser/caffe/caffe_innerproduct_parser.h

@@ -26,6 +26,7 @@ namespace lite {
 class CaffeInnerProductParser : public CaffeNodeParser {
  public:
   CaffeInnerProductParser() : CaffeNodeParser("innerproduct") {}
+  ~CaffeInnerProductParser() = default;
 
   STATUS Parse(const caffe::LayerParameter &proto, const caffe::LayerParameter &weight, schema::CNodeT *op,
                std::vector<schema::TensorT *> *weightVec) override;

mindspore/lite/tools/converter/parser/caffe/caffe_inspector.h

@@ -29,6 +29,7 @@ namespace lite {
 class CaffeInspector {
  public:
   CaffeInspector() = default;
+  ~CaffeInspector() = default;
 
   STATUS InspectModel(const caffe::NetParameter &proto);
   STATUS ParseInput();

mindspore/lite/tools/converter/parser/caffe/caffe_interp_parser.h

@@ -26,6 +26,7 @@ namespace lite {
 class CaffeInterpParser : public CaffeNodeParser {
  public:
   CaffeInterpParser() : CaffeNodeParser("Interp") {}
+  ~CaffeInterpParser() = default;
 
   STATUS Parse(const caffe::LayerParameter &proto, const caffe::LayerParameter &weight, schema::CNodeT *op,
                std::vector<schema::TensorT *> *weightVec) override;

mindspore/lite/tools/converter/parser/caffe/caffe_node_parser.cc

@@ -62,8 +62,11 @@ schema::TensorT *ConvertWeight(const caffe::BlobProto &proto) {
       buf[i] = proto.double_data(i);
     }
     weight->data.resize(count * sizeof(float));
-    ::memcpy_s(weight->data.data(), count * sizeof(float), reinterpret_cast<uint8_t *>(buf.get()),
-               count * sizeof(float));
+    if (::memcpy_s(weight->data.data(), count * sizeof(float), reinterpret_cast<uint8_t *>(buf.get()),
+                   count * sizeof(float)) != EOK) {
+      MS_LOG(ERROR) << "memcpy failed";
+      return nullptr;
+    }
   } else {
     // datatype float
     if (count != proto.data_size()) {
@@ -73,7 +76,10 @@ schema::TensorT *ConvertWeight(const caffe::BlobProto &proto) {
     }
     weight->data.resize(count * sizeof(float));
     const float *data_ptr = proto.data().data();
-    ::memcpy_s(weight->data.data(), count * sizeof(float), (uint8_t *)data_ptr, count * sizeof(float));
+    if (::memcpy_s(weight->data.data(), count * sizeof(float), (uint8_t *)data_ptr, count * sizeof(float)) != EOK) {
+      MS_LOG(ERROR) << "memcpy failed";
+      return nullptr;
+    }
   }
   weight->refCount = 1;
 

mindspore/lite/tools/converter/parser/caffe/caffe_node_parser.h

@@ -30,7 +30,7 @@ namespace mindspore {
 namespace lite {
 class CaffeNodeParser {
  public:
-  explicit CaffeNodeParser(const std::string &nodeName) : name(nodeName) {}
+  explicit CaffeNodeParser(const std::string nodeName) : name(nodeName) {}
 
   virtual ~CaffeNodeParser() {}
 
@@ -38,7 +38,7 @@ class CaffeNodeParser {
                     std::vector<schema::TensorT *> *weightVec) = 0;
 
  protected:
-  const std::string &name;
+  const std::string name;
 };
 
 schema::TensorT *ConvertWeight(const caffe::BlobProto &proto);

mindspore/lite/tools/converter/parser/caffe/caffe_node_parser_registry.h

@@ -41,6 +41,7 @@ class CaffeNodeRegistrar {
   CaffeNodeRegistrar(const std::string &name, CaffeNodeParser *parser) {
     CaffeNodeParserRegistry::GetInstance()->parsers[name] = parser;
   }
+  ~CaffeNodeRegistrar() = default;
 };
 }  // namespace mindspore::lite
 

mindspore/lite/tools/converter/parser/caffe/caffe_permute_parser.h

@@ -26,6 +26,7 @@ namespace lite {
 class CaffePermuteParser : public CaffeNodeParser {
  public:
   CaffePermuteParser() : CaffeNodeParser("Permute") {}
+  ~CaffePermuteParser() = default;
 
   STATUS Parse(const caffe::LayerParameter &proto, const caffe::LayerParameter &weight, schema::CNodeT *op,
                std::vector<schema::TensorT *> *weightVec) override;

mindspore/lite/tools/converter/parser/caffe/caffe_pooling_parser.h

@@ -26,6 +26,7 @@ namespace lite {
 class CaffePoolingParser : public CaffeNodeParser {
  public:
   CaffePoolingParser() : CaffeNodeParser("pooling") {}
+  ~CaffePoolingParser() = default;
 
   STATUS Parse(const caffe::LayerParameter &proto, const caffe::LayerParameter &weight, schema::CNodeT *op,
                std::vector<schema::TensorT *> *weightVec) override;