!446 static check clean

Merge pull request !446 from 徐睿/r1.7.0

parser/caffe/caffe_custom_parser_adapter.cc

@@ -83,7 +83,7 @@ Status CaffeCustomParserAdapter::ParseWeights(const Message *op_src, ge::NodePtr
   GE_CHECK_NOTNULL(op);
   const LayerParameter *layer = reinterpret_cast<const LayerParameter *>(op_src);
 
-  GE_CHK_BOOL_RET_STATUS(nullptr != layer, FAILED, "[Convert][Type]Dynamic cast op_src to LayerParameter failed");
+  GE_CHK_BOOL_RET_STATUS(layer != nullptr, FAILED, "[Convert][Type]Dynamic cast op_src to LayerParameter failed");
   GELOGI("layer: %s blobs_size: %d bottom_size: %d", layer->name().c_str(), layer->blobs_size(), layer->bottom_size());
   if (layer->blobs_size() == 0) {
     return SUCCESS;

parser/caffe/caffe_parser.cc

@@ -861,8 +861,7 @@ Status CaffeModelParser::AddNode(const domi::caffe::LayerParameter &layer, ge::C
   // AddConstInput is a function defined in caffe_op_parser, override in caffe_reshape_parser.
   std::shared_ptr<CaffeOpParser> caffe_op_parser = std::static_pointer_cast<CaffeOpParser>(op_parser);
   GE_CHECK_NOTNULL(caffe_op_parser);
-  Status status;
-  status = caffe_op_parser->AddConstInput(node);
+  Status status = caffe_op_parser->AddConstInput(node);
   if (status != SUCCESS) {
     REPORT_CALL_ERROR("E19999", "AddConstInput failed for node:%s", node->GetOpDesc()->GetName().c_str());
     GELOGE(FAILED, "[Add][ConstInput] to node %s fail.", node->GetOpDesc()->GetName().c_str());
@@ -2099,17 +2098,17 @@ Status CaffeWeightsParser::ConvertLayerParameter(const google::protobuf::Message
                                                  ge::ComputeGraphPtr &graph) {
   vector<string> need_share_layers;
   const domi::caffe::LayerParameter *layer = reinterpret_cast<const domi::caffe::LayerParameter *>(layer_message);
-  const string &layer_name = layer->name();
+  const string &shared_layer_name = layer->name();
   const string &layer_type = layer->type();
   for (auto p_iter = params_share_map.begin(); p_iter != params_share_map.end(); ++p_iter) {
-    if (find(p_iter->second.begin(), p_iter->second.end(), layer_name) != p_iter->second.end()) {
-      GELOGI("layer:%s need share weights !", layer_name.c_str());
+    if (find(p_iter->second.begin(), p_iter->second.end(), shared_layer_name) != p_iter->second.end()) {
+      GELOGI("layer:%s need share weights !", shared_layer_name.c_str());
       need_share_layers = p_iter->second;
     }
   }
 
   if (need_share_layers.size() == 0) {
-    need_share_layers.push_back(layer_name);
+    need_share_layers.push_back(shared_layer_name);
   }
 
   for (auto share_iter = need_share_layers.begin(); share_iter != need_share_layers.end(); ++share_iter) {
@@ -2216,27 +2215,27 @@ Status CaffeWeightsParser::ConvertNetParameter(const NetParameter &param, ge::Co
 
   for (int i = 0; i < num_layer; ++i) {
     const LayerParameter &layer = param.layer(i);
-    const string &layer_name = layer.name();
+    const string &param_layer_name = layer.name();
 
     // Skip some layer types
     if (skiped_layer_type_.find(layer.type()) != skiped_layer_type_.end()) {
-      GELOGI("Skip layer %s", layer_name.c_str());
+      GELOGI("Skip layer %s", param_layer_name.c_str());
       continue;
     }
 
-    GELOGI("Parse layer %s", layer_name.c_str());
+    GELOGI("Parse layer %s", param_layer_name.c_str());
 
     vector<string> need_share_layers;
 
     for (auto p_iter = params_share_map.begin(); p_iter != params_share_map.end(); ++p_iter) {
-      if (find(p_iter->second.begin(), p_iter->second.end(), layer_name) != p_iter->second.end()) {
-        GELOGI("Layer: %s need share weights !", layer_name.c_str());
+      if (find(p_iter->second.begin(), p_iter->second.end(), param_layer_name) != p_iter->second.end()) {
+        GELOGI("Layer: %s need share weights !", param_layer_name.c_str());
         need_share_layers = p_iter->second;
       }
     }
 
     if (need_share_layers.size() == 0) {
-      need_share_layers.push_back(layer_name);
+      need_share_layers.push_back(param_layer_name);
     }
 
     for (auto share_iter = need_share_layers.begin(); share_iter != need_share_layers.end(); ++share_iter) {

parser/caffe/caffe_parser.h

@@ -50,6 +50,7 @@ using std::set;
 using std::string;
 using std::unordered_map;
 using std::vector;
+using domi::Status;
 static std::map<std::vector<std::string>, std::vector<std::string>> params_share_map;
 
 class PARSER_FUNC_VISIBILITY CaffeModelParser : public domi::ModelParser {

parser/common/acl_graph_parser_util.h

@@ -157,7 +157,7 @@ bool ValidateStr(const std::string &filePath, const std::string &mode);
 std::string CurrentTimeInStr();
 
 template <typename T, typename... Args>
-static inline std::shared_ptr<T> MakeShared(Args &&... args) {
+inline std::shared_ptr<T> MakeShared(Args &&... args) {
   using T_nc = typename std::remove_const<T>::type;
   std::shared_ptr<T> ret(new (std::nothrow) T_nc(std::forward<Args>(args)...));
   return ret;

parser/common/op_def/arg_op.cc

@@ -23,11 +23,6 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY ArgOpOperator::ArgOpOperator()
 
 ArgOpOperator::~ArgOpOperator() {}
 
-FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY ArgOpOperator &ArgOpOperator::Name(const std::string &name) {
-  (void)ParserOperator::Name(name);
-  return *this;
-}
-
 FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY ArgOpOperator &ArgOpOperator::Index(int64_t index) {
   Attr("index", static_cast<int64_t>(index));
 

parser/common/op_def/arg_op.h

@@ -25,8 +25,6 @@ class ArgOpOperator : public ParserOperator {
 
   ~ArgOpOperator() override;
 
-  ArgOpOperator &Name(const std::string &name);
-
   ArgOpOperator &Index(int64_t index);
 
   int64_t GetIndex() const;

parser/common/op_def/constant_op.cc

@@ -25,11 +25,6 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY ConstantOperator::ConstantOpera
 
 FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY ConstantOperator::~ConstantOperator() {}
 
-FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY ConstantOperator &ConstantOperator::Name(const std::string &name) {
-  ParserOperator::Name(name);
-  return *this;
-}
-
 FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY ConstantOperator &ConstantOperator::VectorAttr(
     std::string key, std::vector<int64_t> &value) {
   Attr(key, value);

parser/common/op_def/constant_op.h

@@ -26,7 +26,6 @@ class ConstantOperator : public ParserOperator {
   ConstantOperator();
   ~ConstantOperator() override;
 
-  ConstantOperator &Name(const std::string &name);
   ConstantOperator &VectorAttr(std::string key, std::vector<int64_t> &value);
 
   ConstantOperator &DType(ge::DataType t);

parser/common/op_def/frameworkop_op.cc

@@ -24,12 +24,6 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY FrameworkOpOperator::FrameworkO
 
 FrameworkOpOperator::~FrameworkOpOperator() {}
 
-FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY FrameworkOpOperator &FrameworkOpOperator::Name(
-    const std::string &name) {
-  ParserOperator::Name(name);
-  return *this;
-}
-
 FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY FrameworkOpOperator &FrameworkOpOperator::Index(int64_t index) {
   Attr(RETVAL_ATTR_NAME_INDEX, static_cast<int64_t>(index));
   return *this;

parser/common/op_def/frameworkop_op.h

@@ -26,8 +26,6 @@ class FrameworkOpOperator : public ParserOperator {
 
   ~FrameworkOpOperator() override;
 
-  FrameworkOpOperator &Name(const std::string &name);
-
   FrameworkOpOperator &OriginalType(const std::string &type);
 
   FrameworkOpOperator &NodeDefPkg(const std::string &nodedef_pkg);

parser/common/op_def/no_op_op.cc

@@ -22,9 +22,4 @@ namespace ge {
 FMK_FUNC_HOST_VISIBILITY NoOpOperator::NoOpOperator() : ParserOperator("NoOp") {}
 
 FMK_FUNC_HOST_VISIBILITY NoOpOperator::~NoOpOperator() {}
-
-FMK_FUNC_HOST_VISIBILITY NoOpOperator &NoOpOperator::Name(const std::string &name) {
-  ParserOperator::Name(name);
-  return *this;
-}
 }  // namespace ge

parser/common/op_def/no_op_op.h

@@ -25,8 +25,6 @@ class NoOpOperator : public ParserOperator {
  public:
   NoOpOperator();
   ~NoOpOperator() override;
-
-  NoOpOperator &Name(const std::string &name);
 };
 }  // namespace ge
 

parser/common/op_def/operator.h

@@ -45,7 +45,7 @@ class FMK_FUNC_HOST_VISIBILITY ParserOperator {
   ParserOperator &AttrVector(std::string key, std::vector<int32_t> &value);
   ParserOperator &AttrVector(std::string key, std::vector<int64_t> &value);
 
-  ParserOperator &Name(const std::string &name);
+  virtual ParserOperator &Name(const std::string &name);
 
   ParserOperator &Type(const std::string &type);
 

parser/common/op_def/ref_switch_op.cc

@@ -22,11 +22,6 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY RefSwitchOperator::RefSwitchOpe
 
 FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY RefSwitchOperator::~RefSwitchOperator() {}
 
-FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY RefSwitchOperator &RefSwitchOperator::Name(const std::string &name) {
-  ParserOperator::Name(name);
-  return *this;
-}
-
 FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY RefSwitchOperator &RefSwitchOperator::T(ge::DataType t) {
   Attr("T", (int64_t)t);
   return *this;

parser/common/op_def/ref_switch_op.h

@@ -25,8 +25,6 @@ class RefSwitchOperator : public ParserOperator {
  public:
   RefSwitchOperator();
   ~RefSwitchOperator() override;
-
-  RefSwitchOperator &Name(const std::string &name);
   RefSwitchOperator &T(ge::DataType  t);
 };
 }  // namespace ge

parser/common/op_def/shape_n_op.cc

@@ -24,11 +24,6 @@ FMK_FUNC_HOST_VISIBILITY ShapeNOperator::ShapeNOperator() : ParserOperator("Shap
 
 FMK_FUNC_HOST_VISIBILITY ShapeNOperator::~ShapeNOperator() {}
 
-FMK_FUNC_HOST_VISIBILITY ShapeNOperator &ShapeNOperator::Name(const std::string &name) {
-  ParserOperator::Name(name);
-  return *this;
-}
-
 FMK_FUNC_HOST_VISIBILITY ShapeNOperator &ShapeNOperator::N(int64_t n) {
   Attr(SHAPEN_ATTR_N, n);
   return *this;

parser/common/op_def/shape_n_op.h

@@ -26,8 +26,6 @@ class ShapeNOperator : public ParserOperator {
   ShapeNOperator();
   ~ShapeNOperator() override;
 
-  ShapeNOperator &Name(const std::string &name);
-
   ShapeNOperator &N(int64_t n);
   int64_t GetN() const;
   ShapeNOperator &InType(ge::DataType t);

parser/common/op_def/var_is_initialized_op_op.cc

@@ -24,11 +24,6 @@ VarIsInitializedOpOperator::VarIsInitializedOpOperator() : ParserOperator(ge::pa
 
 VarIsInitializedOpOperator::~VarIsInitializedOpOperator() {}
 
-VarIsInitializedOpOperator &VarIsInitializedOpOperator::Name(const std::string &name) {
-  ParserOperator::Name(name);
-  return *this;
-}
-
 VarIsInitializedOpOperator &VarIsInitializedOpOperator::VectorAttr(const std::string &key,
                                                                    std::vector<int64_t> &value) {
   Attr(key, value);

parser/common/op_def/var_is_initialized_op_op.h

@@ -26,7 +26,6 @@ class VarIsInitializedOpOperator : public ParserOperator {
   VarIsInitializedOpOperator();
   ~VarIsInitializedOpOperator() override;
 
-  VarIsInitializedOpOperator &Name(const std::string &name);
   VarIsInitializedOpOperator &VectorAttr(const std::string &key, std::vector<int64_t> &value);
 };
 }  // namespace ge

parser/common/op_def/variable_op.cc

@@ -23,11 +23,6 @@ VariableOperator::VariableOperator() : ParserOperator(ge::parser::VARIABLE) {}
 
 VariableOperator::~VariableOperator() {}
 
-VariableOperator &VariableOperator::Name(const std::string &name) {
-  ParserOperator::Name(name);
-  return *this;
-}
-
 VariableOperator &VariableOperator::Container(const std::string &container) {
   Attr(VAR_ATTR_CONTAINER, container);
   return *this;

parser/common/op_def/variable_op.h

@@ -27,8 +27,6 @@ class VariableOperator : public ParserOperator {
   VariableOperator();
   ~VariableOperator() override;
 
-  VariableOperator &Name(const std::string &name);
-
   VariableOperator &Container(const std::string &container);
 
   VariableOperator &SharedName(const std::string &sharedname);

parser/common/parser_fp16_t.cc

@@ -675,8 +675,7 @@ static uint16_t Fp16Div(uint16_t v_1, uint16_t v_2) {
     uint64_t m_tmp;
     if (e_a > e_b) {
       m_tmp = m_a;
-      uint16_t tmp;
-      tmp = e_a - e_b;
+      uint16_t tmp = e_a - e_b;
       for (int i = 0; i < tmp; i++) {
         m_tmp = m_tmp << 1;
       }
@@ -690,8 +689,7 @@ static uint16_t Fp16Div(uint16_t v_1, uint16_t v_2) {
       m_b = m_tmp;
     }
     m_div = static_cast<float>(m_a * 1.0f / m_b);
-    fp16_t fp_div;
-    fp_div = m_div;
+    fp16_t fp_div = m_div;
     ret = fp_div.val;
     if (s_a != s_b) {
       ret |= kFp16SignMask;

parser/common/parser_utils.cc

@@ -212,8 +212,7 @@ Status ParserUtils::HandleInputContext(const NodePtr &node,
       // add control edge
       if (node->GetInControlAnchor() != nullptr) {
         for (const auto &out_anchor : node->GetInControlAnchor()->GetPeerAnchors()) {
-          graphStatus ret = GraphUtils::AddEdge(out_anchor, peer_in_anchor->GetOwnerNode()->GetInControlAnchor());
-          if (ret != GRAPH_SUCCESS) {
+          if (GraphUtils::AddEdge(out_anchor, peer_in_anchor->GetOwnerNode()->GetInControlAnchor()) != GRAPH_SUCCESS) {
             REPORT_CALL_ERROR("E19999", "add control edge from %s to %s failed.",
                               out_anchor->GetOwnerNode()->GetName().c_str(),
                               peer_in_anchor->GetOwnerNode()->GetName().c_str());

parser/onnx/onnx_parser.cc

@@ -767,8 +767,8 @@ Status OnnxModelParser::AdaptAndFindAllOnnxGraph(ge::onnx::GraphProto &root_onnx
         return FAILED;
       }
 
-      for (const auto &onnx_graph : onnx_graphs) {
-        onnx_graph_tasks.push(onnx_graph);
+      for (const auto &sub_onnx_graph : onnx_graphs) {
+        onnx_graph_tasks.push(sub_onnx_graph);
       }
       for (const auto &itr : name_to_onnx_subgraph) {
         name_to_onnx_graph.emplace(itr.first, itr.second);

parser/onnx/subgraph_adapter/subgraph_adapter_factory.h

@@ -32,6 +32,7 @@
 #endif
 
 #include <map>
+#include <memory>
 #include <functional>
 #include "subgraph_adapter.h"
 

parser/tensorflow/tensorflow_parser.cc

@@ -1515,7 +1515,7 @@ Status TensorFlowModelParser::ParseAllGraph(const google::protobuf::Message *pro
     if (tensorflow_op_map.find(node_op) == tensorflow_op_map.end()) {
       GELOGW("%s not found in tensorflow_op_map.", node_op.c_str());
     }
-    Status ret = AddNode(node_def, graph, scope_graph);
+    ret = AddNode(node_def, graph, scope_graph);
     if (ret != SUCCESS) {
       GELOGE(ret, "Add op[%s] failed", node_def->name().c_str());
       DeleteFuisonNodeDef();
@@ -1675,7 +1675,6 @@ Status TensorFlowModelParser::CheckInputNodeName(const string &input_node_name,
     }
   }
 
-  int32_t tmp_index = 0;
   auto find = tmp_input_node_name.find(":");
   if (find == string::npos) {
     *node_name = tmp_input_node_name;
@@ -1683,7 +1682,7 @@ Status TensorFlowModelParser::CheckInputNodeName(const string &input_node_name,
     if (index == nullptr) {
       return SUCCESS;
     }
-    *index = tmp_index;
+    *index = 0;
 
     return SUCCESS;
   }
@@ -2010,15 +2009,13 @@ Status TensorFlowModelParser::EraseNormalOpOutputIfChild(shared_ptr<ge::ScopeGra
   for (auto iter = normal_op_node_context.output_map.begin(); iter != normal_op_node_context.output_map.end();) {
     string output_node_name = iter->first;
     ge::ScopeFusionOpInfo to_info;
-    int32_t from_index = 0;
-    int32_t to_index = 0;
-
     if (IsFusionOpChild(output_node_name, &to_info) &&
         nodedef_map_[output_node_name]->op() != TENSORFLOWF_NODE_OP_CONST) {
       // Fuse operator, update index
       std::vector<std::pair<int32_t, int32_t>> &pairs = iter->second;
+      int32_t to_index = 0;
       for (auto &pair : pairs) {
-        from_index = pair.first;
+        int32_t from_index = pair.first;
         GE_RETURN_WITH_LOG_IF_ERROR(GetInPutIndex(scope_graph, to_info, pair.second, to_index),
                                     "GetInPutIndex failed ,output_node_name %s.", output_node_name.c_str());
         tmp_output_map[to_info.fusion_node_name].push_back({from_index, to_index});
@@ -2047,15 +2044,13 @@ Status TensorFlowModelParser::UpdateNormalOpContext(shared_ptr<ge::ScopeGraph> &
   for (auto iter = normal_op_node_context.input_map.begin(); iter != normal_op_node_context.input_map.end();) {
     string input_node_name = iter->first;
     ge::ScopeFusionOpInfo from_info;
-    int32_t from_index = 0;
-    int32_t to_index = 0;
-
     if (IsFusionOpChild(input_node_name, &from_info) &&
         nodedef_map_[input_node_name]->op() != TENSORFLOWF_NODE_OP_CONST) {
       // Fuse operator, update index
       std::vector<std::pair<int32_t, int32_t>> &pairs = iter->second;
+      int32_t from_index = 0;
       for (auto &pair : pairs) {
-        to_index = pair.second;
+        int32_t to_index = pair.second;
         GE_RETURN_WITH_LOG_IF_ERROR(GetOutPutIndex(scope_graph, from_info, pair.first, from_index),
                                     "GetOutPutIndex failed ,input_node_name %s.", input_node_name.c_str());
         tmp_input_map[from_info.fusion_node_name].push_back({from_index, to_index});
@@ -2277,7 +2272,7 @@ Status TensorFlowModelParser::ParseProto(const google::protobuf::Message *proto,
     }
 
     // Do not exit immediately when there is an error, wait until all errors are collected before exiting
-    Status ret = AddFmkNodeDefToMap(node_def, op_node_name_list);
+    ret = AddFmkNodeDefToMap(node_def, op_node_name_list);
     GE_CHK_STATUS_EXEC(ret, return PARAM_INVALID, "add node_def to map failed");
   }
   PARSER_TIMESTAMP_END(AddFmkNodeDefToMap, "TensorFlowModelParser::AddFmkNodeDefToMap");
@@ -3135,8 +3130,7 @@ Status TensorFlowModelParser::TrimGraphByInput(const domi::tensorflow::GraphDef
   output_graph_def->Clear();
   for (const NodeDef &node : filtered_graph_def.node()) {
     if (input_nodes.count(node.name())) {
-      NodeDef placeholder_node;
-      placeholder_node = node;
+      NodeDef placeholder_node = node;
       placeholder_node.clear_input();
       GE_IF_BOOL_EXEC(node.op() != "Placeholder", placeholder_node.set_op("Placeholder"));
       domi::tensorflow::AttrValue attr_value;
@@ -3209,8 +3203,7 @@ Status TensorFlowModelParser::TrimGraphByOutput(const domi::tensorflow::GraphDef
   output_graph_def->Clear();
   for (const NodeDef &node : filtered_graph_def.node()) {
     if (input_nodes.count(node.name())) {
-      NodeDef placeholder_node;
-      placeholder_node = node;
+      NodeDef placeholder_node = node;
       placeholder_node.clear_input();
       GE_IF_BOOL_EXEC(node.op() != "Placeholder", placeholder_node.set_op("Placeholder"));
       domi::tensorflow::AttrValue attr_value;
@@ -3732,8 +3725,8 @@ void TensorFlowModelParser::UpdateInnerInputMap(const string &fusion_op_name, Op
       std::map<std::string, std::vector<std::pair<int32_t, int32_t>>> tmp_input_map;
       for (auto iter = op_node_context.input_map.begin(); iter != op_node_context.input_map.end();) {
         string src_name = iter->first;
-        std::vector<std::pair<int32_t, int32_t>> &input_idx = iter->second;
         if (src_name == ge::kInputFromFusionScope) {
+          std::vector<std::pair<int32_t, int32_t>> &input_idx = iter->second;
           for (const auto &in_pair : input_idx) {
             if (in_pair.second != kControlSlot) {
               auto data = remap_data_input[fusion_op_name + std::to_string(in_pair.first)];
@@ -3779,8 +3772,8 @@ void TensorFlowModelParser::UpdateInnerOutputMap(const string &fusion_op_name, O
       std::map<std::string, std::vector<std::pair<int32_t, int32_t>>> tmp_output_map;
       for (auto iter = op_node_context.output_map.begin(); iter != op_node_context.output_map.end();) {
         string dst_name = iter->first;
-        std::vector<std::pair<int32_t, int32_t>> &output_idx = iter->second;
         if (dst_name == ge::kOutputToFusionScope) {
+          std::vector<std::pair<int32_t, int32_t>> &output_idx = iter->second;
           for (const auto &out_pair : output_idx) {
             if (out_pair.second != kControlSlot) {
               auto data_outputs = remap_data_output[fusion_op_name + std::to_string(out_pair.second)];

parser/tensorflow/tensorflow_reshape_parser.cc

@@ -33,9 +33,6 @@ Status TensorFlowReshapeParser::ParseDesc(const domi::tensorflow::AttrValue &att
   GE_CHK_BOOL_RET_STATUS(TensorFlowUtil::ParseFromAttrValueList(ge_desc, a_list, 0, tf_datatype), PARAM_INVALID,
                          "parse ge_desc failed.");
   uint32_t size_type = 1;
-  int64_t real_size = 1;
-  int64_t tmp_dim = 0;
-
   auto data_type = ge_desc.GetDataType();
   bool type_ret = ge::TypeUtils::GetDataTypeLength(data_type, size_type);
   GE_IF_BOOL_EXEC(!type_ret,
@@ -45,6 +42,8 @@ Status TensorFlowReshapeParser::ParseDesc(const domi::tensorflow::AttrValue &att
                          ge::TypeUtils::DataTypeToSerialString(data_type).c_str());
                   return PARAM_INVALID);
   // calculate size
+  int64_t tmp_dim = 0;
+  int64_t real_size = 1;
   for (uint32_t j = 0; j < ge_desc.GetShape().GetDimNum(); ++j) {
     tmp_dim = ge_desc.GetShape().GetDim(j);
     GE_IF_BOOL_EXEC(tmp_dim < 0, real_size = tmp_dim * (-1) * real_size; continue;);

parser/tensorflow/tensorflow_squeeze_parser.cc

@@ -37,9 +37,6 @@ Status TensorFlowSqueezeParser::ParseDesc(const domi::tensorflow::AttrValue &att
   GE_CHK_BOOL_RET_STATUS(TensorFlowUtil::ParseFromAttrValueList(ge_desc, a_list, 0, tf_datatype), domi::PARAM_INVALID,
                          "parse ge_desc failed.");
   uint32_t size_type;
-  int64_t real_size = 1;
-  int64_t tmp_dim = 0;
-
   auto data_type = ge_desc.GetDataType();
   bool type_ret = ge::TypeUtils::GetDataTypeLength(data_type, size_type);
   GE_IF_BOOL_EXEC(!type_ret,
@@ -49,6 +46,8 @@ Status TensorFlowSqueezeParser::ParseDesc(const domi::tensorflow::AttrValue &att
                          ge::TypeUtils::DataTypeToSerialString(data_type).c_str());
                   return domi::PARAM_INVALID);
   // calculate size
+  int64_t real_size = 1;
+  int64_t tmp_dim = 0;
   for (uint32_t j = 0; j < ge_desc.GetShape().GetDimNum(); ++j) {
     tmp_dim = ge_desc.GetShape().GetDim(j);
     GE_IF_BOOL_EXEC(tmp_dim < 0, real_size = tmp_dim * (-1) * real_size; continue;);

parser/tensorflow/tensorflow_util.cc

@@ -267,11 +267,11 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY domi::Status TensorFlowUtil::Tr
     GE_CHK_BOOL_RET_STATUS(ParseFromAttrValueList(ge_desc, a_list, i, tf_datatype), PARAM_INVALID,
                            "parse ge_desc failed.");
     uint32_t size_type = 1;
-    int64_t tmp_dim = 0;
     auto data_type = ge_desc.GetDataType();
     GE_CHK_BOOL_RET_STATUS(ge::TypeUtils::GetDataTypeLength(data_type, size_type), PARAM_INVALID,
                            "dataType no define size , parse ge_desc failed.");
     // get size
+    int64_t tmp_dim = 0;
     for (uint32_t j = 0; j < ge_desc.GetShape().GetDimNum(); ++j) {
       tmp_dim = ge_desc.GetShape().GetDim(j);