sync commercial pclint clean

mindspore/ccsrc/backend/kernel_compiler/cpu/nnacl/infer/uniform_real_infer.c

@@ -33,7 +33,7 @@ int UniformRealInferShape(const TensorC *const *inputs, size_t inputs_size, Tens
     return NNACL_INFER_INVALID;
   }
   int input_num = GetElementNum(inputs[0]);
-  if (input_num > MAX_SHAPE_SIZE) {
+  if (input_num > MAX_SHAPE_SIZE || input_num < 0) {
     return NNACL_INPUT_TENSOR_ERROR;
   }
   int output_shape[MAX_SHAPE_SIZE];

mindspore/lite/src/common/config_file.cc

@@ -36,7 +36,7 @@ void ParseLine(const std::string &line, std::map<std::string, std::string> *sect
   //     key=value
   if (line[0] == '[' && line[line.length() - 1] == ']') {
     if (!section->empty() && !section_config->empty()) {
-      config->insert(std::make_pair(*section, *section_config));
+      (void)config->insert(std::make_pair(*section, *section_config));
     }
     section_config->clear();
     *section = line.substr(1, line.length() - kLengthOfParentheses);
@@ -55,7 +55,7 @@ void ParseLine(const std::string &line, std::map<std::string, std::string> *sect
     auto value = line.substr(index + 1);
     lite::Trim(&key);
     lite::Trim(&value);
-    section_config->insert(std::make_pair(key, value));
+    (void)section_config->insert(std::make_pair(key, value));
     *valid_line_count = *valid_line_count + 1;
   }
 }
@@ -109,7 +109,7 @@ int GetAllSectionInfoFromConfigFile(const std::string &file,
     ParseLine(line, &section_config, &section, &valid_line_count, config);
   }
   if (!section.empty() && !section_config.empty()) {
-    config->insert(std::make_pair(section, section_config));
+    (void)config->insert(std::make_pair(section, section_config));
   }
   ifs.close();
   return RET_OK;
@@ -150,7 +150,7 @@ void ParserExecutionPlan(const std::map<std::string, std::string> *config_infos,
       MS_LOG(WARNING) << "Invalid value in execution_plan: " << value;
       continue;
     }
-    data_type_plan->insert(std::make_pair(op_name, type_id));
+    (void)data_type_plan->insert(std::make_pair(op_name, type_id));
   }
 }
 }  // namespace lite

mindspore/lite/src/cxx_api/model/model_impl.cc

@@ -37,9 +37,9 @@
 
 namespace mindspore {
 namespace {
-static const char *kExecutionPlan = "execution_plan";
-static constexpr size_t kMaxSectionNum = 100;
-static constexpr size_t kMaxConfigNumPerSection = 1000;
+const char *const kExecutionPlan = "execution_plan";
+constexpr size_t kMaxSectionNum = 100;
+constexpr size_t kMaxConfigNumPerSection = 1000;
 }  // namespace
 using mindspore::lite::RET_ERROR;
 using mindspore::lite::RET_OK;

mindspore/lite/src/lite_model.cc

@@ -319,7 +319,7 @@ bool LiteModel::ModelVerify() const {
     }
   }
 
-  if (std::any_of(this->output_indices_.begin(), this->output_indices_.end(),
+  if (std::any_of(output_indices_.begin(), output_indices_.end(),
                   [&all_tensors_size](const uint32_t &idx) { return idx >= all_tensors_size; })) {
     MS_LOG(ERROR) << "Graph output indices is beyond tensor_size.";
     return false;

mindspore/lite/src/ms_tensor.cc

@@ -27,12 +27,16 @@ tensor::MSTensor *tensor::MSTensor::CreateTensor(const std::string &name, TypeId
     return nullptr;
   }
 
-  int shape_size = 1;
+  size_t shape_size = 1;
   if (shape.empty()) {
     shape_size = 0;
   } else {
     for (size_t i = 0; i < shape.size(); ++i) {
-      shape_size *= shape[i];
+      if (shape[i] < 0) {
+        delete tensor;
+        return nullptr;
+      }
+      shape_size *= static_cast<size_t>(shape[i]);
     }
   }
   auto data_type_size = lite::DataTypeSize(type);

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

@@ -27,7 +27,7 @@ OpParameter *PopulateClipParameter(const void *prim) {
     MS_LOG(ERROR) << "malloc ClipParameter failed.";
     return nullptr;
   }
-  memset(param, 0, sizeof(OpParameter));
+  (void)memset(param, 0, sizeof(OpParameter));
 
   param->type_ = primitive->value_type();
   return reinterpret_cast<OpParameter *>(param);

mindspore/lite/src/runtime/infer_manager.cc

@@ -65,11 +65,13 @@ int KernelInferShape(const std::vector<lite::Tensor *> &inputs, const std::vecto
     return RET_NOT_SUPPORT;
   }
   std::vector<mindspore::MSTensor> in_tensors;
-  std::transform(inputs.begin(), inputs.end(), std::back_inserter(in_tensors),
-                 [](lite::Tensor *tensor) { return mindspore::MSTensor(std::make_shared<MSTensor::Impl>(tensor)); });
+  (void)std::transform(inputs.begin(), inputs.end(), std::back_inserter(in_tensors), [](lite::Tensor *tensor) {
+    return mindspore::MSTensor(std::make_shared<MSTensor::Impl>(tensor));
+  });
   std::vector<mindspore::MSTensor> out_tensors;
-  std::transform(outputs.begin(), outputs.end(), std::back_inserter(out_tensors),
-                 [](lite::Tensor *tensor) { return mindspore::MSTensor(std::make_shared<MSTensor::Impl>(tensor)); });
+  (void)std::transform(outputs.begin(), outputs.end(), std::back_inserter(out_tensors), [](lite::Tensor *tensor) {
+    return mindspore::MSTensor(std::make_shared<MSTensor::Impl>(tensor));
+  });
   auto ret =
     kernel_interface->Infer(&in_tensors, &out_tensors, static_cast<const schema::Primitive *>(primitive), kernel);
   if (ret == kLiteInferInvalid) {

mindspore/lite/src/runtime/inner_allocator.cc

@@ -28,7 +28,7 @@ DefaultAllocator::~DefaultAllocator() { Clear(); }
 
 void DefaultAllocator::SetContext(const AllocatorContext &ctx) {
   lockFlag_ = ctx.lockFlag;
-  shiftFactor_ = ctx.shiftFactor;
+  shiftFactor_ = static_cast<unsigned>(ctx.shiftFactor);
 }
 
 void DefaultAllocator::Lock() {
@@ -43,7 +43,7 @@ void DefaultAllocator::UnLock() {
   }
 }
 
-bool DefaultAllocator::ReuseMemory(size_t free_size, size_t size) {
+bool DefaultAllocator::ReuseMemory(size_t free_size, size_t size) const {
   return free_size >= size &&
          (free_size <= (size >= UINT32_MAX / (1ul << shiftFactor_) ? UINT32_MAX : size << shiftFactor_));
 }
@@ -62,7 +62,7 @@ void *DefaultAllocator::Malloc(size_t size) {
   if (iter != freeList_.end() && ReuseMemory(iter->second->size, size)) {
     auto membuf = iter->second;
     membuf->ref_count_ = 0;
-    freeList_.erase(iter);
+    (void)freeList_.erase(iter);
     allocatedList_[membuf->buf] = membuf;
     UnLock();
     return membuf->buf;
@@ -94,8 +94,8 @@ void DefaultAllocator::Free(void *buf) {
   if (iter != allocatedList_.end()) {
     auto membuf = iter->second;
     membuf->ref_count_ = 0;
-    allocatedList_.erase(iter);
-    freeList_.insert(std::make_pair(membuf->size, membuf));
+    (void)allocatedList_.erase(iter);
+    (void)freeList_.insert(std::make_pair(membuf->size, membuf));
     UnLock();
     return;
   }

mindspore/lite/src/runtime/inner_allocator.h

@@ -50,7 +50,7 @@ class DefaultAllocator : public Allocator {
  private:
   void Lock();
   void UnLock();
-  bool ReuseMemory(size_t free_size, size_t size);
+  bool ReuseMemory(size_t free_size, size_t size) const;
   struct MemBuf {
     std::atomic_int ref_count_ = {0};
     size_t size = 0;

mindspore/lite/src/runtime/kernel/arm/fp32/gather_fp32.cc

@@ -125,7 +125,7 @@ int GatherCPUKernel::AssignIndicesData(bool isIndicesInt32, int indices_num, lit
     switch (indices_tensor->data_type()) {
       case kNumberTypeInt64:
         for (int i = 0; i < indices_num; i++) {
-          indices_data_[i] = reinterpret_cast<int64_t *>(indices_tensor->MutableData())[i];
+          indices_data_[i] = static_cast<int>(reinterpret_cast<int64_t *>(indices_tensor->MutableData())[i]);
         }
         break;
       case kNumberTypeFloat:

mindspore/lite/src/runtime/kernel/arm/fp32/glu_fp32.cc

@@ -34,7 +34,7 @@ const int kGluBranchNum = 2;
 int GluCPUKernel::MallocTmpBuffer() {
   FreeTmpBuffer();
   auto in_tensor = in_tensors_.front();
-  for (int i = 0; i < kSplitNum; i++) {
+  for (size_t i = 0; i < kSplitNum; i++) {
     split_ptr_[i] = ms_context_->allocator->Malloc(in_tensor->Size() / kSplitNum);
     if (split_ptr_[i] == nullptr) {
       MS_LOG(ERROR) << "GluCPUKernel malloc split ptr failed.";
@@ -50,7 +50,7 @@ int GluCPUKernel::MallocTmpBuffer() {
 }
 
 void GluCPUKernel::FreeTmpBuffer() {
-  for (int i = 0; i < kSplitNum; i++) {
+  for (size_t i = 0; i < kSplitNum; i++) {
     if (split_ptr_.at(i) != nullptr) {
       ms_context_->allocator->Free(split_ptr_.at(i));
       split_ptr_.at(i) = nullptr;

mindspore/lite/src/runtime/kernel/arm/fp32/glu_fp32.h

@@ -28,7 +28,7 @@
 using mindspore::lite::InnerContext;
 
 namespace mindspore::kernel {
-constexpr int kSplitNum = 2;
+constexpr size_t kSplitNum = 2;
 
 class GluCPUKernel : public InnerKernel {
  public:

mindspore/lite/src/runtime/runtime_pass.cc

@@ -33,7 +33,7 @@ void Nc4hw4PassReplace(std::vector<kernel::LiteKernel *> *kernels, std::vector<T
   {
     /* transpose_kernel */
     Tensor *transpose_param_tensor = transpose_kernel->in_tensors().at(1);
-    VectorSetNull(tensors, transpose_param_tensor);
+    (void)VectorSetNull(tensors, transpose_param_tensor);
     delete transpose_param_tensor;
     transpose_param_tensor = nullptr;
 
@@ -41,14 +41,14 @@ void Nc4hw4PassReplace(std::vector<kernel::LiteKernel *> *kernels, std::vector<T
     conv_out_tensor->set_format(NC4HW4);
     Tensor *c4_input_tensor = c4_kernel->in_tensors().front();
     c4_kernel->set_in_tensor(conv_out_tensor, 0);
-    VectorSetNull(tensors, c4_input_tensor);
+    (void)VectorSetNull(tensors, c4_input_tensor);
     delete c4_input_tensor;
     c4_input_tensor = nullptr;
   }
   {
     /* transpose2_kernel */
     Tensor *transpose_param_tensor = transpose2_kernel->in_tensors().at(1);
-    VectorSetNull(tensors, transpose_param_tensor);
+    (void)VectorSetNull(tensors, transpose_param_tensor);
     delete transpose_param_tensor;
     transpose_param_tensor = nullptr;
 
@@ -61,13 +61,13 @@ void Nc4hw4PassReplace(std::vector<kernel::LiteKernel *> *kernels, std::vector<T
       end->set_in_tensor(nwhc_tensor, 0);
     }
     Tensor *trans_out = transpose2_kernel->out_tensors().front();
-    VectorSetNull(tensors, trans_out);
+    (void)VectorSetNull(tensors, trans_out);
     delete trans_out;
     trans_out = nullptr;
   }
 
   /* kernel */
-  VectorErase(kernels, transpose_kernel);
+  (void)VectorErase(kernels, transpose_kernel);
   delete transpose_kernel;
   transpose_kernel = nullptr;
   conv_kernel->set_out_kernels({c4_kernel});
@@ -77,7 +77,7 @@ void Nc4hw4PassReplace(std::vector<kernel::LiteKernel *> *kernels, std::vector<T
   for (auto end : end_kernels) {
     end->set_in_kernels({c4_kernel});
   }
-  VectorErase(kernels, transpose2_kernel);
+  (void)VectorErase(kernels, transpose2_kernel);
   delete transpose2_kernel;
   transpose2_kernel = nullptr;