1From e101f6e61047ccd0a7531f426de7ba837800da0a Mon Sep 17 00:00:00 2001 2From: rabbit-fgh <2955722401@qq.com> 3Date: Mon, 26 Aug 2024 11:55:13 +0800 4Subject: [PATCH] nullptr1 5 6fix nullptr2 7--- 8 mindspore/lite/mindir/src/mindir.cc | 163 ++++++++++-------- 9 mindspore/lite/mindir/src/mindir_tensor.cc | 3 +- 10 .../control_flow/kernel/identity_kernel.cc | 11 +- 11 mindspore/lite/src/litert/c_api/model_c.cc | 11 ++ 12 mindspore/lite/src/litert/cache_session.cc | 4 + 13 .../lite/src/litert/cxx_api/model/model.cc | 12 +- 14 mindspore/lite/src/litert/lite_mindrt.cc | 4 + 15 .../lite/src/litert/pack_weight_manager.cc | 3 + 16 .../cast_gather_reduce_fusion_pass.cc | 1 + 17 .../reduce_concat_fusion_pass.cc | 1 + 18 .../split_reduce_concat_fusion_pass.cc | 1 + 19 mindspore/lite/src/litert/weight_decoder.cc | 2 + 20 12 files changed, 134 insertions(+), 82 deletions(-) 21 22diff --git a/mindspore/lite/mindir/src/mindir.cc b/mindspore/lite/mindir/src/mindir.cc 23index 39600e4d..93204fb8 100644 24--- a/mindspore/lite/mindir/src/mindir.cc 25+++ b/mindspore/lite/mindir/src/mindir.cc 26@@ -37,13 +37,16 @@ PrimitivePtr MindIR_Activation_CreatePrimitive(ActivationType activation_type, f 27 ActivationType MindIR_Activation_GetActivationType(ConstPrimitivePtr primitive) { 28 if (primitive != nullptr) { 29 auto prim = static_cast<const schema::Primitive *>(primitive); 30+ if (prim == nullptr) { 31+ ActivationType en = static_cast<ActivationType>(0); 32+ return en; 33+ } 34 auto value = prim->value_as_Activation(); 35- if (prim != nullptr && value != nullptr) { 36- return static_cast<ActivationType>(value->activation_type()); 37- } else { 38+ if (value == nullptr) { 39 ActivationType en = static_cast<ActivationType>(0); 40 return en; 41 } 42+ return static_cast<ActivationType>(value->activation_type()); 43 } else { 44 ActivationType en = static_cast<ActivationType>(0); 45 return en; 46@@ -53,30 +56,34 @@ ActivationType MindIR_Activation_GetActivationType(ConstPrimitivePtr primitive) 47 void MindIR_Activation_SetActivationType(PrimitivePtr *primitive, ActivationType activation_type) { 48 if (primitive != nullptr && *primitive != nullptr) { 49 auto prim = static_cast<schema::Primitive *>(*primitive); 50- auto value = prim->value_as_Activation(); 51- if (prim != nullptr && value != nullptr) { 52- flatbuffers::FlatBufferBuilder fbb; 53- auto ops_offset = 54- schema::CreateActivation(fbb, static_cast<schema::ActivationType>(activation_type), value->alpha(), 55- value->min_val(), value->max_val(), value->approximate()); 56- auto prim_offset = 57- schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_ACTIVATION), ops_offset.o); 58- fbb.Finish(prim_offset); 59- auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, prim); 60- auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 61- *primitive = ret_value; 62+ if(prim != nullptr){ 63+ auto value = prim->value_as_Activation(); 64+ if (value != nullptr) { 65+ flatbuffers::FlatBufferBuilder fbb; 66+ auto ops_offset = 67+ schema::CreateActivation(fbb, static_cast<schema::ActivationType>(activation_type), value->alpha(), 68+ value->min_val(), value->max_val(), value->approximate()); 69+ auto prim_offset = 70+ schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_ACTIVATION), ops_offset.o); 71+ fbb.Finish(prim_offset); 72+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, prim); 73+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 74+ *primitive = ret_value; 75+ } 76 } 77 } 78 } 79 float MindIR_Activation_GetAlpha(ConstPrimitivePtr primitive) { 80 if (primitive != nullptr) { 81 auto prim = static_cast<const schema::Primitive *>(primitive); 82+ if(prim == nullptr){ 83+ return .0; 84+ } 85 auto value = prim->value_as_Activation(); 86- if (prim != nullptr && value != nullptr) { 87- return value->alpha(); 88- } else { 89+ if(value == nullptr){ 90 return .0; 91 } 92+ return value->alpha(); 93 } else { 94 return .0; 95 } 96@@ -85,29 +92,33 @@ float MindIR_Activation_GetAlpha(ConstPrimitivePtr primitive) { 97 void MindIR_Activation_SetAlpha(PrimitivePtr *primitive, float alpha) { 98 if (primitive != nullptr && *primitive != nullptr) { 99 auto prim = static_cast<schema::Primitive *>(*primitive); 100- auto value = prim->value_as_Activation(); 101- if (prim != nullptr && value != nullptr) { 102- flatbuffers::FlatBufferBuilder fbb; 103- auto ops_offset = schema::CreateActivation(fbb, static_cast<schema::ActivationType>(value->activation_type()), 104- alpha, value->min_val(), value->max_val(), value->approximate()); 105- auto prim_offset = 106- schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_ACTIVATION), ops_offset.o); 107- fbb.Finish(prim_offset); 108- auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, prim); 109- auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 110- *primitive = ret_value; 111+ if(prim != nullptr){ 112+ auto value = prim->value_as_Activation(); 113+ if (value != nullptr) { 114+ flatbuffers::FlatBufferBuilder fbb; 115+ auto ops_offset = schema::CreateActivation(fbb, static_cast<schema::ActivationType>(value->activation_type()), 116+ alpha, value->min_val(), value->max_val(), value->approximate()); 117+ auto prim_offset = 118+ schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_ACTIVATION), ops_offset.o); 119+ fbb.Finish(prim_offset); 120+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, prim); 121+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 122+ *primitive = ret_value; 123+ } 124 } 125 } 126 } 127 float MindIR_Activation_GetMinVal(ConstPrimitivePtr primitive) { 128 if (primitive != nullptr) { 129 auto prim = static_cast<const schema::Primitive *>(primitive); 130+ if(prim == nullptr){ 131+ return .0; 132+ } 133 auto value = prim->value_as_Activation(); 134- if (prim != nullptr && value != nullptr) { 135- return value->min_val(); 136- } else { 137+ if(value == nullptr){ 138 return .0; 139 } 140+ return value->min_val(); 141 } else { 142 return .0; 143 } 144@@ -116,29 +127,33 @@ float MindIR_Activation_GetMinVal(ConstPrimitivePtr primitive) { 145 void MindIR_Activation_SetMinVal(PrimitivePtr *primitive, float min_val) { 146 if (primitive != nullptr && *primitive != nullptr) { 147 auto prim = static_cast<schema::Primitive *>(*primitive); 148- auto value = prim->value_as_Activation(); 149- if (prim != nullptr && value != nullptr) { 150- flatbuffers::FlatBufferBuilder fbb; 151- auto ops_offset = schema::CreateActivation(fbb, static_cast<schema::ActivationType>(value->activation_type()), 152- value->alpha(), min_val, value->max_val(), value->approximate()); 153- auto prim_offset = 154- schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_ACTIVATION), ops_offset.o); 155- fbb.Finish(prim_offset); 156- auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, prim); 157- auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 158- *primitive = ret_value; 159+ if(prim != nullptr){ 160+ auto value = prim->value_as_Activation(); 161+ if (value != nullptr) { 162+ flatbuffers::FlatBufferBuilder fbb; 163+ auto ops_offset = schema::CreateActivation(fbb, static_cast<schema::ActivationType>(value->activation_type()), 164+ value->alpha(), min_val, value->max_val(), value->approximate()); 165+ auto prim_offset = 166+ schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_ACTIVATION), ops_offset.o); 167+ fbb.Finish(prim_offset); 168+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, prim); 169+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 170+ *primitive = ret_value; 171+ } 172 } 173 } 174 } 175 float MindIR_Activation_GetMaxVal(ConstPrimitivePtr primitive) { 176 if (primitive != nullptr) { 177 auto prim = static_cast<const schema::Primitive *>(primitive); 178+ if(prim == nullptr){ 179+ return .0; 180+ } 181 auto value = prim->value_as_Activation(); 182- if (prim != nullptr && value != nullptr) { 183- return value->max_val(); 184- } else { 185+ if(value == nullptr){ 186 return .0; 187 } 188+ return value->max_val(); 189 } else { 190 return .0; 191 } 192@@ -147,29 +162,33 @@ float MindIR_Activation_GetMaxVal(ConstPrimitivePtr primitive) { 193 void MindIR_Activation_SetMaxVal(PrimitivePtr *primitive, float max_val) { 194 if (primitive != nullptr && *primitive != nullptr) { 195 auto prim = static_cast<schema::Primitive *>(*primitive); 196- auto value = prim->value_as_Activation(); 197- if (prim != nullptr && value != nullptr) { 198- flatbuffers::FlatBufferBuilder fbb; 199- auto ops_offset = schema::CreateActivation(fbb, static_cast<schema::ActivationType>(value->activation_type()), 200- value->alpha(), value->min_val(), max_val, value->approximate()); 201- auto prim_offset = 202- schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_ACTIVATION), ops_offset.o); 203- fbb.Finish(prim_offset); 204- auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, prim); 205- auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 206- *primitive = ret_value; 207+ if(prim != nullptr){ 208+ auto value = prim->value_as_Activation(); 209+ if (value != nullptr) { 210+ flatbuffers::FlatBufferBuilder fbb; 211+ auto ops_offset = schema::CreateActivation(fbb, static_cast<schema::ActivationType>(value->activation_type()), 212+ value->alpha(), value->min_val(), max_val, value->approximate()); 213+ auto prim_offset = 214+ schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_ACTIVATION), ops_offset.o); 215+ fbb.Finish(prim_offset); 216+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, prim); 217+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 218+ *primitive = ret_value; 219+ } 220 } 221 } 222 } 223 bool MindIR_Activation_GetApproximate(ConstPrimitivePtr primitive) { 224 if (primitive != nullptr) { 225 auto prim = static_cast<const schema::Primitive *>(primitive); 226+ if(prim == nullptr){ 227+ return false; 228+ } 229 auto value = prim->value_as_Activation(); 230- if (prim != nullptr && value != nullptr) { 231- return value->approximate(); 232- } else { 233+ if(value == nullptr){ 234 return false; 235 } 236+ return value->approximate(); 237 } else { 238 return false; 239 } 240@@ -178,17 +197,19 @@ bool MindIR_Activation_GetApproximate(ConstPrimitivePtr primitive) { 241 void MindIR_Activation_SetApproximate(PrimitivePtr *primitive, bool approximate) { 242 if (primitive != nullptr && *primitive != nullptr) { 243 auto prim = static_cast<schema::Primitive *>(*primitive); 244- auto value = prim->value_as_Activation(); 245- if (prim != nullptr && value != nullptr) { 246- flatbuffers::FlatBufferBuilder fbb; 247- auto ops_offset = schema::CreateActivation(fbb, static_cast<schema::ActivationType>(value->activation_type()), 248- value->alpha(), value->min_val(), value->max_val(), approximate); 249- auto prim_offset = 250- schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_ACTIVATION), ops_offset.o); 251- fbb.Finish(prim_offset); 252- auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, prim); 253- auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 254- *primitive = ret_value; 255+ if(prim != nullptr){ 256+ auto value = prim->value_as_Activation(); 257+ if (value != nullptr) { 258+ flatbuffers::FlatBufferBuilder fbb; 259+ auto ops_offset = schema::CreateActivation(fbb, static_cast<schema::ActivationType>(value->activation_type()), 260+ value->alpha(), value->min_val(), value->max_val(), approximate); 261+ auto prim_offset = 262+ schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_ACTIVATION), ops_offset.o); 263+ fbb.Finish(prim_offset); 264+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, prim); 265+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 266+ *primitive = ret_value; 267+ } 268 } 269 } 270 } 271diff --git a/mindspore/lite/mindir/src/mindir_tensor.cc b/mindspore/lite/mindir/src/mindir_tensor.cc 272index 0e6a631e..c7dd19b2 100644 273--- a/mindspore/lite/mindir/src/mindir_tensor.cc 274+++ b/mindspore/lite/mindir/src/mindir_tensor.cc 275@@ -54,7 +54,7 @@ TensorPtr MindIR_Tensor_Create(const char *name, DataType data_type, const int32 276 std::string MindIR_Tensor_GetName(ConstTensorPtr tensor) { 277 if (tensor != nullptr) { 278 auto value = static_cast<const schema::Tensor *>(tensor); 279- if (value != nullptr) { 280+ if (value != nullptr && value->name() != nullptr) { 281 return value->name()->str(); 282 } else { 283 return ""; 284@@ -360,7 +360,6 @@ void MindIR_Tensor_Destroy(TensorPtr *tensor) { 285 MindIRMemoryManager::GetInstance()->DeleteTensor(schema); 286 *tensor = nullptr; 287 } 288- *tensor = nullptr; 289 } 290 } // namespace lite 291 } // namespace mindspore 292diff --git a/mindspore/lite/src/control_flow/kernel/identity_kernel.cc b/mindspore/lite/src/control_flow/kernel/identity_kernel.cc 293index a43a5caf..21ef3808 100644 294--- a/mindspore/lite/src/control_flow/kernel/identity_kernel.cc 295+++ b/mindspore/lite/src/control_flow/kernel/identity_kernel.cc 296@@ -99,8 +99,13 @@ KernelExec *IdentityKernel::Create(std::vector<lite::Tensor *> in_tensors, std:: 297 auto lite_kernel = new IdentityKernel(param, in_tensors, out_tensors, ctx); 298 MS_CHECK_TRUE_MSG(lite_kernel != nullptr, nullptr, "new inner kernel failed."); 299 std::shared_ptr<kernel::Kernel> shared_kernel(lite_kernel); 300- auto *kernel_exec = new KernelExec(shared_kernel); 301- kernel_exec->set_context(ctx); 302- return kernel_exec; 303+ if(shared_kernel != nullptr){ 304+ auto *kernel_exec = new KernelExec(shared_kernel); 305+ kernel_exec->set_context(ctx); 306+ return kernel_exec; 307+ } else { 308+ MS_LOG(ERROR) << "malloc shared_kernel failed."; 309+ return nullptr; 310+ } 311 } 312 } // namespace mindspore::kernel 313diff --git a/mindspore/lite/src/litert/c_api/model_c.cc b/mindspore/lite/src/litert/c_api/model_c.cc 314index 4f40b3d3..661a8d06 100644 315--- a/mindspore/lite/src/litert/c_api/model_c.cc 316+++ b/mindspore/lite/src/litert/c_api/model_c.cc 317@@ -385,6 +385,13 @@ char **OH_AI_TrainCfgGetLossName(OH_AI_TrainCfgHandle train_cfg, size_t *num) { 318 } 319 for (size_t i = 0; i < loss_name.size(); i++) { 320 name[i] = static_cast<char *>(malloc(loss_name[i].size() + 1)); 321+ if (name[i] == nullptr) { 322+ for(size_t j = 0; j < i; j++){ 323+ free(name[j]); 324+ } 325+ MS_LOG(ERROR) << "Failed to malloc name."; 326+ return nullptr; 327+ } 328 strcpy(name[i], loss_name[i].c_str()); 329 } 330 return name; 331@@ -618,6 +625,10 @@ OH_AI_Status OH_AI_ExportModelBuffer(OH_AI_ModelHandle model, OH_AI_ModelType mo 332 export_inference_only, tensor_name); 333 auto data = static_cast<char *>(buffer.MutableData()); 334 *model_data = (char *) malloc(buffer.DataSize()); 335+ if (*model_data == nullptr) { 336+ MS_LOG(ERROR) << "*model_data is nullptr."; 337+ return OH_AI_STATUS_LITE_NULLPTR; 338+ } 339 *data_size = buffer.DataSize(); 340 memcpy(*model_data, data, buffer.DataSize()); 341 if (!ret.IsOk()) { 342diff --git a/mindspore/lite/src/litert/cache_session.cc b/mindspore/lite/src/litert/cache_session.cc 343index 7bafe3f7..e128c933 100644 344--- a/mindspore/lite/src/litert/cache_session.cc 345+++ b/mindspore/lite/src/litert/cache_session.cc 346@@ -209,6 +209,10 @@ int CacheSession::LoadModelAndCompileByPath(const std::string &model_path, minds 347 return RET_ERROR; 348 } else { 349 model = ImportInOutFromBuffer(model_buf, model_size, true, model_type, model_path); 350+ if (model == nullptr) { 351+ MS_LOG(ERROR) << "Import model failed"; 352+ return RET_ERROR; 353+ } 354 dynamic_cast<LiteModel *>(model)->PrepareInnerTensors(); 355 } 356 if (model == nullptr) { 357diff --git a/mindspore/lite/src/litert/cxx_api/model/model.cc b/mindspore/lite/src/litert/cxx_api/model/model.cc 358index 2814da41..282c752e 100644 359--- a/mindspore/lite/src/litert/cxx_api/model/model.cc 360+++ b/mindspore/lite/src/litert/cxx_api/model/model.cc 361@@ -297,6 +297,12 @@ Status Model::Build(const std::vector<char> &model_path, ModelType model_type, 362 363 Status Model::Build(GraphCell graph, const std::shared_ptr<Context> &model_context, 364 const std::shared_ptr<TrainCfg> &train_cfg) { 365+std::stringstream err_msg; 366+if (model_context == nullptr) { 367+ err_msg << "Invalid null context."; 368+ MS_LOG(ERROR) << err_msg.str(); 369+ return Status(kLiteNullptr, err_msg.str()); 370+} 371 #ifdef ENABLE_HI_APP_EVENT 372 uint64_t begin_time = mindspore::lite::HiAppEventConfig::GetInstance()->GetTimeMs(); 373 std::string devices; 374@@ -304,7 +310,6 @@ Status Model::Build(GraphCell graph, const std::shared_ptr<Context> &model_conte 375 devices += std::to_string(device->GetDeviceType()) + " "; 376 } 377 #endif 378- std::stringstream err_msg; 379 if (impl_ == nullptr) { 380 MS_LOG(ERROR) << "Model implement is null."; 381 return kLiteNullptr; 382@@ -315,11 +320,6 @@ Status Model::Build(GraphCell graph, const std::shared_ptr<Context> &model_conte 383 MS_LOG(ERROR) << err_msg.str(); 384 return Status(kLiteNullptr, err_msg.str()); 385 } 386- if (model_context == nullptr) { 387- err_msg << "Invalid null context."; 388- MS_LOG(ERROR) << err_msg.str(); 389- return Status(kLiteNullptr, err_msg.str()); 390- } 391 #if defined(ENABLE_PRE_INFERENCE) && defined(__linux__) && !defined(Debug) 392 if (lite::GetNumThreads() == lite::kSingleThread && impl_->IsEnablePreInference()) { 393 pid_t pid = fork(); 394diff --git a/mindspore/lite/src/litert/lite_mindrt.cc b/mindspore/lite/src/litert/lite_mindrt.cc 395index fe7b64f2..4d1b4ba6 100644 396--- a/mindspore/lite/src/litert/lite_mindrt.cc 397+++ b/mindspore/lite/src/litert/lite_mindrt.cc 398@@ -106,6 +106,10 @@ int LiteOpActor::IsolateInputData(std::vector<std::shared_ptr<LiteOpActor>> *act 399 old_tensor->set_data_type(kernel_->desc().data_type); 400 } 401 SetTensorListTensorDataType(kernel_->desc().data_type, old_tensor); 402+ if (kernel_->Context() == nullptr) { 403+ MS_LOG(ERROR) << "kernel_->Context() is nullptr."; 404+ return RET_NULL_PTR; 405+ } 406 old_tensor->set_allocator(kernel_->Context()->allocator); 407 continue; 408 } 409diff --git a/mindspore/lite/src/litert/pack_weight_manager.cc b/mindspore/lite/src/litert/pack_weight_manager.cc 410index 09f4e4b4..554bf4dc 100644 411--- a/mindspore/lite/src/litert/pack_weight_manager.cc 412+++ b/mindspore/lite/src/litert/pack_weight_manager.cc 413@@ -264,6 +264,9 @@ void PackWeightManager::FreePackWeight(std::string runner_id, std::string model_ 414 MS_LOG(INFO) << "free pack weight of runner id: " << runner_id; 415 pack_weight_->FreePackWeight(runner_id); 416 } 417+ } else { 418+ MS_LOG(INFO) << "pack_weight_ is nullptr."; 419+ return; 420 } 421 if (model_id.empty()) { 422 MS_LOG(INFO) << "model id is empty."; 423diff --git a/mindspore/lite/src/litert/pass/online_fusion/cast_gather_reduce_fusion_pass.cc b/mindspore/lite/src/litert/pass/online_fusion/cast_gather_reduce_fusion_pass.cc 424index 4892292c..00186dc7 100644 425--- a/mindspore/lite/src/litert/pass/online_fusion/cast_gather_reduce_fusion_pass.cc 426+++ b/mindspore/lite/src/litert/pass/online_fusion/cast_gather_reduce_fusion_pass.cc 427@@ -127,6 +127,7 @@ int CastGatherReduceOnlineFusionPass::CreateCastGatherReduceCustomNode(LiteGraph 428 (void)memcpy(prim, fbb.GetBufferPointer(), fbb.GetSize()); 429 auto online_fusion_prim = flatbuffers::GetRoot<schema::Primitive>(prim); 430 if (online_fusion_prim == nullptr) { 431+ free(prim) 432 MS_LOG(ERROR) << "GetRoot CastGatherReduceFusion primitive failed."; 433 return RET_ERROR; 434 } 435diff --git a/mindspore/lite/src/litert/pass/online_fusion/reduce_concat_fusion_pass.cc b/mindspore/lite/src/litert/pass/online_fusion/reduce_concat_fusion_pass.cc 436index 5cfec79b..21115cc5 100644 437--- a/mindspore/lite/src/litert/pass/online_fusion/reduce_concat_fusion_pass.cc 438+++ b/mindspore/lite/src/litert/pass/online_fusion/reduce_concat_fusion_pass.cc 439@@ -135,6 +135,7 @@ int ReduceConcatOnlineFusionPass::CreateReduceConcatCustomNode(LiteGraph::Node * 440 (void)memcpy(prim, fbb.GetBufferPointer(), fbb.GetSize()); 441 auto online_fusion_prim = flatbuffers::GetRoot<schema::Primitive>(prim); 442 if (online_fusion_prim == nullptr) { 443+ free(prim) 444 MS_LOG(ERROR) << "GetRoot ReduceConcatFusion primitive failed."; 445 return RET_ERROR; 446 } 447diff --git a/mindspore/lite/src/litert/pass/online_fusion/split_reduce_concat_fusion_pass.cc b/mindspore/lite/src/litert/pass/online_fusion/split_reduce_concat_fusion_pass.cc 448index e6f1353f..f9a08a04 100644 449--- a/mindspore/lite/src/litert/pass/online_fusion/split_reduce_concat_fusion_pass.cc 450+++ b/mindspore/lite/src/litert/pass/online_fusion/split_reduce_concat_fusion_pass.cc 451@@ -233,6 +233,7 @@ int SplitReduceConcatOnlineFusionPass::CreateCustomNode(LiteGraph::Node *node, S 452 (void)memcpy(prim, fbb.GetBufferPointer(), fbb.GetSize()); 453 auto online_fusion_prim = flatbuffers::GetRoot<schema::Primitive>(prim); 454 if (online_fusion_prim == nullptr) { 455+ free(prim) 456 MS_LOG(ERROR) << "GetRoot SplitReduceConcatFusion primitive failed."; 457 return RET_ERROR; 458 } 459diff --git a/mindspore/lite/src/litert/weight_decoder.cc b/mindspore/lite/src/litert/weight_decoder.cc 460index d851ea1f..7872b83f 100644 461--- a/mindspore/lite/src/litert/weight_decoder.cc 462+++ b/mindspore/lite/src/litert/weight_decoder.cc 463@@ -177,6 +177,8 @@ int WeightDecoder::UnPackToInt(const SchemaTensorWrapper &src_tensor, lite::Tens 464 int WeightDecoder::UnPack(const SchemaTensorWrapper &src_tensor, lite::Tensor *dst_tensor) { 465 MS_ASSERT(src_tensor.handler() != nullptr); 466 MS_ASSERT(src_tensor.data() != nullptr); 467+ MS_CHECK_TRUE_MSG(src_tensor.handler()->dims() != nullptr, RET_ERROR, "dims is nullptr"); 468+ MS_CHECK_TRUE_MSG(src_tensor.handler()->name() != nullptr, RET_ERROR, "name is nullptr"); 469 STATUS ret = RET_OK; 470 if (src_tensor.handler()->enableHuffmanCode()) { 471 ret = WeightDecoder::DecodeHuffmanCode(src_tensor, dst_tensor); 472-- 4732.45.1.windows.1 474 475