diff options
| -rw-r--r-- | safercpp/safercpp-arr.cpp | 475 |
1 files changed, 419 insertions, 56 deletions
diff --git a/safercpp/safercpp-arr.cpp b/safercpp/safercpp-arr.cpp index 98e72e2..970d130 100644 --- a/safercpp/safercpp-arr.cpp +++ b/safercpp/safercpp-arr.cpp @@ -336,6 +336,24 @@ public: virtual ~CDynamicArray2ReplacementAction() {} }; +class CMemsetArray2ReplacementAction : public CDynamicArray2ReplacementAction { +public: + CMemsetArray2ReplacementAction(Rewriter &Rewrite, const MatchFinder::MatchResult &MR, const CDDeclIndirection& ddecl_indirection, + const CallExpr* CE, const std::string& ce_replacement_code) : + CDynamicArray2ReplacementAction(Rewrite, MR, ddecl_indirection), m_CE(CE), m_DD(ddecl_indirection.m_ddecl_cptr), + m_ce_replacement_code(ce_replacement_code) { + } + virtual ~CMemsetArray2ReplacementAction() {} + + virtual void do_replacement(CState1& state1) const; + + const CallExpr* m_CE = nullptr; + //const DeclRefExpr* m_DRE = nullptr; + //const MemberExpr* m_ME = nullptr; + const DeclaratorDecl* m_DD = nullptr; + std::string m_ce_replacement_code; +}; + class CSetArrayPointerToNull2ReplacementAction : public CDynamicArray2ReplacementAction { public: CSetArrayPointerToNull2ReplacementAction(Rewriter &Rewrite, const MatchFinder::MatchResult &MR, const CDDeclIndirection& ddecl_indirection, @@ -580,6 +598,11 @@ const clang::Expr* populateStmtIndirectionStack(std::vector<std::string>& stack, } else { assert(false); } + } else { + if (0 == depth) { + int q = 5; + } + int q = 5; } if (process_child_flag) { auto child_iter = ST->child_begin(); @@ -660,6 +683,16 @@ static CDeclarationReplacementCodeItem generate_declaration_replacement_code(con direct_qtype_str = "const bool"; } + std::string variable_name = DD->getNameAsString(); + std::string identifier_name_str; + auto pIdentifier = DD->getIdentifier(); + if (pIdentifier) { + identifier_name_str = pIdentifier->getName(); + } + if ("" == variable_name) { + int q = 7; + } + clang::StorageDuration storage_duration = clang::StorageDuration::SD_Automatic; bool has_dynamic_storage_duration = false; bool is_a_temporary = false; @@ -680,11 +713,28 @@ static CDeclarationReplacementCodeItem generate_declaration_replacement_code(con if (ddcs_ref.m_original_initialization_has_been_noted) { initialization_expr_str = ddcs_ref.m_original_initialization_expr_str; + if ("" != ddcs_ref.m_original_initialization_expr_str) { + int q = 5; + } } else { - auto pInitExpr = VD->getInit(); - if (VD->hasInit() && pInitExpr) { - auto init_expr_source_range = nice_source_range(pInitExpr->getSourceRange(), Rewrite); - initialization_expr_str = Rewrite.getRewrittenText(init_expr_source_range); + if (VD->hasInit()) { + auto pInitExpr = VD->getInit(); + if (pInitExpr) { + auto init_expr_source_range = nice_source_range(pInitExpr->getSourceRange(), Rewrite); + if (init_expr_source_range.isValid()) { + initialization_expr_str = Rewrite.getRewrittenText(init_expr_source_range); + if (variable_name == initialization_expr_str) { + /* We encountered a weird bug where the initialization expression sometimes + * was indicated as being present and the source range set to the variable name + * when actually no initialization expression was present in the original source. */ + initialization_expr_str = ""; + } + } else { + int q = 3; + } + } else { + int q = 3; + } ddcs_ref.m_original_initialization_expr_str = initialization_expr_str; } ddcs_ref.m_original_initialization_has_been_noted = true; @@ -696,11 +746,28 @@ static CDeclarationReplacementCodeItem generate_declaration_replacement_code(con if (ddcs_ref.m_original_initialization_has_been_noted) { initialization_expr_str = ddcs_ref.m_original_initialization_expr_str; + if ("" != ddcs_ref.m_original_initialization_expr_str) { + int q = 5; + } } else { - auto pInitExpr = FD->getInClassInitializer(); - if (FD->hasInClassInitializer() && pInitExpr) { - auto init_expr_source_range = nice_source_range(pInitExpr->getSourceRange(), Rewrite); - initialization_expr_str = Rewrite.getRewrittenText(init_expr_source_range); + if (FD->hasInClassInitializer()) { + auto pInitExpr = FD->getInClassInitializer(); + if (pInitExpr) { + auto init_expr_source_range = nice_source_range(pInitExpr->getSourceRange(), Rewrite); + if (init_expr_source_range.isValid()) { + initialization_expr_str = Rewrite.getRewrittenText(init_expr_source_range); + if (variable_name == initialization_expr_str) { + /* We encountered a weird bug where the initialization expression sometimes + * was indicated as being present and the source range set to the variable name + * when actually no initialization expression was present in the original source. */ + initialization_expr_str = ""; + } + } else { + int q = 3; + } + } else { + int q = 3; + } ddcs_ref.m_original_initialization_expr_str = initialization_expr_str; } ddcs_ref.m_original_initialization_has_been_noted = true; @@ -709,16 +776,6 @@ static CDeclarationReplacementCodeItem generate_declaration_replacement_code(con } ddcs_ref.m_original_initialization_has_been_noted = true; - std::string variable_name = DD->getNameAsString(); - std::string identifier_name_str; - auto pIdentifier = DD->getIdentifier(); - if (pIdentifier) { - identifier_name_str = pIdentifier->getName(); - } - if ("" == variable_name) { - int q = 7; - } - std::string replacement_code; std::string prefix_str; std::string suffix_str; @@ -932,7 +989,40 @@ static void update_declaration(const DeclaratorDecl& ddecl, Rewriter &Rewrite, C } } -void CSetArrayPointerToNull2ReplacementAction::do_replacement(CState1& state1) const { +void CFreeDynamicArray2ReplacementAction::do_replacement(CState1& state1) const { + Rewriter &Rewrite = m_Rewrite; + const MatchFinder::MatchResult &MR = m_MR; + const CallExpr* CE = m_CE; + const DeclaratorDecl* DD = m_DD; + + if ((CE != nullptr) && (DD != nullptr)) + { + auto CESR = nice_source_range(CE->getSourceRange(), Rewrite); + auto decl_source_range = nice_source_range(DD->getSourceRange(), Rewrite); + auto decl_source_location_str = decl_source_range.getBegin().printToString(*MR.SourceManager); + std::string decl_source_text; + if (decl_source_range.isValid()) { + decl_source_text = Rewrite.getRewrittenText(decl_source_range); + } else { + return; + } + + if (ConvertToSCPP && decl_source_range.isValid() && (CESR.isValid())) { + + update_declaration(*DD, Rewrite, state1); + + //state1.m_array2_contingent_replacement_map.do_and_dispose_matching_replacements(state1, (*this).ddecl_indirection_cref()); + //state1.m_dynamic_array2_contingent_replacement_map.do_and_dispose_matching_replacements(state1, (*this).ddecl_indirection_cref()); + + auto res2 = Rewrite.ReplaceText(CESR, m_ce_replacement_code); + int q = 3; + } else { + int q = 7; + } + } +} + +void CMallocArray2ReplacementAction::do_replacement(CState1& state1) const { Rewriter &Rewrite = m_Rewrite; const MatchFinder::MatchResult &MR = m_MR; const BinaryOperator* BO = m_BO; @@ -965,15 +1055,14 @@ void CSetArrayPointerToNull2ReplacementAction::do_replacement(CState1& state1) c } } -void CFreeDynamicArray2ReplacementAction::do_replacement(CState1& state1) const { +void CMallocInitializerArray2ReplacementAction::do_replacement(CState1& state1) const { Rewriter &Rewrite = m_Rewrite; const MatchFinder::MatchResult &MR = m_MR; - const CallExpr* CE = m_CE; + const DeclStmt* DS = m_DS; const DeclaratorDecl* DD = m_DD; - if ((CE != nullptr) && (DD != nullptr)) + if ((DS != nullptr) && (DD != nullptr)) { - auto CESR = nice_source_range(CE->getSourceRange(), Rewrite); auto decl_source_range = nice_source_range(DD->getSourceRange(), Rewrite); auto decl_source_location_str = decl_source_range.getBegin().printToString(*MR.SourceManager); std::string decl_source_text; @@ -983,14 +1072,18 @@ void CFreeDynamicArray2ReplacementAction::do_replacement(CState1& state1) const return; } - if (ConvertToSCPP && decl_source_range.isValid() && (CESR.isValid())) { + auto res1 = state1.m_ddecl_conversion_state_map.insert(*DD); + auto ddcs_map_iter = res1.first; + auto& ddcs_ref = (*ddcs_map_iter).second; + ddcs_ref.m_initializer_info_str = m_initializer_info_str; + + if (ConvertToSCPP && decl_source_range.isValid()) { update_declaration(*DD, Rewrite, state1); //state1.m_array2_contingent_replacement_map.do_and_dispose_matching_replacements(state1, (*this).ddecl_indirection_cref()); //state1.m_dynamic_array2_contingent_replacement_map.do_and_dispose_matching_replacements(state1, (*this).ddecl_indirection_cref()); - auto res2 = Rewrite.ReplaceText(CESR, m_ce_replacement_code); int q = 3; } else { int q = 7; @@ -998,7 +1091,7 @@ void CFreeDynamicArray2ReplacementAction::do_replacement(CState1& state1) const } } -void CMallocArray2ReplacementAction::do_replacement(CState1& state1) const { +void CSetArrayPointerToNull2ReplacementAction::do_replacement(CState1& state1) const { Rewriter &Rewrite = m_Rewrite; const MatchFinder::MatchResult &MR = m_MR; const BinaryOperator* BO = m_BO; @@ -1020,9 +1113,6 @@ void CMallocArray2ReplacementAction::do_replacement(CState1& state1) const { update_declaration(*DD, Rewrite, state1); - //state1.m_array2_contingent_replacement_map.do_and_dispose_matching_replacements(state1, (*this).ddecl_indirection_cref()); - //state1.m_dynamic_array2_contingent_replacement_map.do_and_dispose_matching_replacements(state1, (*this).ddecl_indirection_cref()); - auto res2 = Rewrite.ReplaceText(BOSR, m_bo_replacement_code); int q = 3; } else { @@ -1031,14 +1121,15 @@ void CMallocArray2ReplacementAction::do_replacement(CState1& state1) const { } } -void CMallocInitializerArray2ReplacementAction::do_replacement(CState1& state1) const { +void CMemsetArray2ReplacementAction::do_replacement(CState1& state1) const { Rewriter &Rewrite = m_Rewrite; const MatchFinder::MatchResult &MR = m_MR; - const DeclStmt* DS = m_DS; + const CallExpr* CE = m_CE; const DeclaratorDecl* DD = m_DD; - if ((DS != nullptr) && (DD != nullptr)) + if ((CE != nullptr) && (DD != nullptr)) { + auto CESR = nice_source_range(CE->getSourceRange(), Rewrite); auto decl_source_range = nice_source_range(DD->getSourceRange(), Rewrite); auto decl_source_location_str = decl_source_range.getBegin().printToString(*MR.SourceManager); std::string decl_source_text; @@ -1048,18 +1139,11 @@ void CMallocInitializerArray2ReplacementAction::do_replacement(CState1& state1) return; } - auto res1 = state1.m_ddecl_conversion_state_map.insert(*DD); - auto ddcs_map_iter = res1.first; - auto& ddcs_ref = (*ddcs_map_iter).second; - - ddcs_ref.m_initializer_info_str = m_initializer_info_str; + if (ConvertToSCPP && decl_source_range.isValid() && (CESR.isValid())) { - if (ConvertToSCPP && decl_source_range.isValid()) { update_declaration(*DD, Rewrite, state1); - //state1.m_array2_contingent_replacement_map.do_and_dispose_matching_replacements(state1, (*this).ddecl_indirection_cref()); - //state1.m_dynamic_array2_contingent_replacement_map.do_and_dispose_matching_replacements(state1, (*this).ddecl_indirection_cref()); - + auto res2 = Rewrite.ReplaceText(CESR, m_ce_replacement_code); int q = 3; } else { int q = 7; @@ -1394,7 +1478,7 @@ public: } int q = 5; } else { - int q = 5; + return; } if (update_declaration_flag) { @@ -1414,8 +1498,8 @@ private: class MCSSSMalloc2 : public MatchFinder::MatchCallback { public: - MCSSSMalloc2 (Rewriter &Rewrite, CState1& state1) -: Rewrite(Rewrite), m_state1(state1) {} + MCSSSMalloc2 (Rewriter &Rewrite, CState1& state1) : + Rewrite(Rewrite), m_state1(state1) {} virtual void run(const MatchFinder::MatchResult &MR) { @@ -1645,6 +1729,11 @@ public: indirection_level = i; m_state1.m_dynamic_array2_contingent_replacement_map.do_and_dispose_matching_replacements(m_state1, CDDeclIndirection(*DD, i)); } + } else if ("dynamic array" == ddcs_ref.m_indirection_state_stack[i].m_current) { + if (("malloc target" == stmt_indirection_stack[i])) { + lhs_has_been_determined_to_be_an_array = true; + indirection_level = i; + } } else { assert(!(("native array" == ddcs_ref.m_indirection_state_stack[i].m_current) && (("malloc target" == stmt_indirection_stack[i])))); @@ -1656,7 +1745,7 @@ public: } int q = 5; } else { - int q = 5; + return; } if (update_declaration_flag) { @@ -1886,6 +1975,8 @@ public: lhs_has_been_determined_to_be_an_array = true; //update_declaration_flag = true; m_state1.m_dynamic_array2_contingent_replacement_map.do_and_dispose_matching_replacements(m_state1, CDDeclIndirection(*DD, 0)); + } else if ("dynamic array" == ddcs_ref.m_indirection_state_stack[0].m_current) { + lhs_has_been_determined_to_be_an_array = true; } else { assert("native array" != ddcs_ref.m_indirection_state_stack[0].m_current); } @@ -1963,8 +2054,8 @@ private: class MCSSSFree2 : public MatchFinder::MatchCallback { public: - MCSSSFree2 (Rewriter &Rewrite, CState1& state1) -: Rewrite(Rewrite), m_state1(state1) {} + MCSSSFree2 (Rewriter &Rewrite, CState1& state1) : + Rewrite(Rewrite), m_state1(state1) {} virtual void run(const MatchFinder::MatchResult &MR) { @@ -2075,10 +2166,10 @@ public: } std::vector<std::string> stmt_indirection_stack; - const clang::Expr* expr2 = populateStmtIndirectionStack(stmt_indirection_stack, *CE); + const clang::Expr* expr2 = populateStmtIndirectionStack(stmt_indirection_stack, *(*(CE->arg_begin()))); std::reverse(stmt_indirection_stack.begin(), stmt_indirection_stack.end()); stmt_indirection_stack.push_back("malloc target"); - bool lhs_has_been_determined_to_be_an_array = false; + bool target_has_been_determined_to_be_an_array = false; size_t indirection_level = 0; if (expr2) { std::string expr2_stmt_class_name; @@ -2121,10 +2212,15 @@ public: if (("malloc target" == stmt_indirection_stack[i])) { ddcs_ref.m_indirection_state_stack[i].m_current = "dynamic array"; update_declaration_flag = true; - lhs_has_been_determined_to_be_an_array = true; + target_has_been_determined_to_be_an_array = true; indirection_level = i; m_state1.m_dynamic_array2_contingent_replacement_map.do_and_dispose_matching_replacements(m_state1, CDDeclIndirection(*DD, i)); } + } else if ("dynamic array" == ddcs_ref.m_indirection_state_stack[i].m_current) { + if (("malloc target" == stmt_indirection_stack[i])) { + target_has_been_determined_to_be_an_array = true; + indirection_level = i; + } } else { assert(!(("native array" == ddcs_ref.m_indirection_state_stack[i].m_current) && (("malloc target" == stmt_indirection_stack[i])))); @@ -2136,7 +2232,7 @@ public: } int q = 5; } else { - int q = 5; + return; } if (update_declaration_flag) { @@ -2149,7 +2245,7 @@ public: if (ConvertToSCPP && decl_source_range.isValid() && (CESR.isValid())) { auto cr_shptr = std::make_shared<CFreeDynamicArray2ReplacementAction>(Rewrite, MR, CDDeclIndirection(*DD, indirection_level), CE, ce_replacement_code); - if (lhs_has_been_determined_to_be_an_array) { + if (target_has_been_determined_to_be_an_array) { (*cr_shptr).do_replacement(m_state1); } else { m_state1.m_dynamic_array2_contingent_replacement_map.insert(cr_shptr); @@ -2178,8 +2274,8 @@ private: class MCSSSSetToNull2 : public MatchFinder::MatchCallback { public: - MCSSSSetToNull2 (Rewriter &Rewrite, CState1& state1) -: Rewrite(Rewrite), m_state1(state1) {} + MCSSSSetToNull2 (Rewriter &Rewrite, CState1& state1) : + Rewrite(Rewrite), m_state1(state1) {} virtual void run(const MatchFinder::MatchResult &MR) { @@ -2337,6 +2433,11 @@ public: indirection_level = i; m_state1.m_dynamic_array2_contingent_replacement_map.do_and_dispose_matching_replacements(m_state1, CDDeclIndirection(*DD, i)); } + } else if ("dynamic array" == ddcs_ref.m_indirection_state_stack[i].m_current) { + if (("malloc target" == stmt_indirection_stack[i])) { + lhs_has_been_determined_to_be_an_array = true; + indirection_level = i; + } } else { assert(!(("native array" == ddcs_ref.m_indirection_state_stack[i].m_current) && (("malloc target" == stmt_indirection_stack[i])))); @@ -2348,7 +2449,7 @@ public: } int q = 5; } else { - int q = 5; + return; } if (update_declaration_flag) { @@ -2386,6 +2487,254 @@ private: CState1& m_state1; }; +class MCSSSMemset : public MatchFinder::MatchCallback +{ +public: + MCSSSMemset (Rewriter &Rewrite, CState1& state1) : + Rewrite(Rewrite), m_state1(state1) {} + + virtual void run(const MatchFinder::MatchResult &MR) + { + const CallExpr* CE = MR.Nodes.getNodeAs<clang::CallExpr>("mcsssmemset1"); + const DeclRefExpr* DRE = MR.Nodes.getNodeAs<clang::DeclRefExpr>("mcsssmemset2"); + const MemberExpr* ME = MR.Nodes.getNodeAs<clang::MemberExpr>("mcsssmemset3"); + + if ((CE != nullptr) && (DRE != nullptr)) + { + auto CESR = nice_source_range(CE->getSourceRange(), Rewrite); + SourceLocation CESL = CESR.getBegin(); + SourceLocation CESLE = CESR.getEnd(); + + ASTContext *const ASTC = MR.Context; + FullSourceLoc FCESL = ASTC->getFullLoc(CESL); + + SourceManager &SM = ASTC->getSourceManager(); + + auto source_location_str = CESL.printToString(*MR.SourceManager); + std::string source_text; + if (CESL.isValid() && CESLE.isValid()) { + source_text = Rewrite.getRewrittenText(SourceRange(CESL, CESLE)); + } else { + return; + } + + if (filtered_out_by_location(MR, CESL)) { + return void(); + } + + auto function_decl = CE->getDirectCallee(); + auto num_args = CE->getNumArgs(); + if (function_decl && (3 == num_args)) { + { + std::string function_name = function_decl->getNameAsString(); + static const std::string memset_str = "memset"; + if (memset_str == function_name) { + auto iter1 = CE->arg_begin(); + assert((*iter1)->getType().getTypePtrOrNull()); + auto arg_source_range1 = nice_source_range((*iter1)->getSourceRange(), Rewrite); + + auto iter2 = iter1; + iter2++; + assert((*iter2)->getType().getTypePtrOrNull()); + auto arg_source_range2 = nice_source_range((*iter2)->getSourceRange(), Rewrite); + + auto iter3 = iter2; + iter3++; + assert((*iter3)->getType().getTypePtrOrNull()); + auto arg_source_range3 = nice_source_range((*iter3)->getSourceRange(), Rewrite); + + std::string arg_source_text1; + std::string arg_source_text2; + std::string arg_source_text3; + if (arg_source_range1.isValid() && arg_source_range2.isValid() && arg_source_range3.isValid()) { + arg_source_text1 = Rewrite.getRewrittenText(arg_source_range1); + arg_source_text2 = Rewrite.getRewrittenText(arg_source_range2); + arg_source_text3 = Rewrite.getRewrittenText(arg_source_range3); + QualType QT; + std::string element_type_str; + clang::SourceRange decl_source_range; + std::string variable_name; + std::string ce_replacement_code; + const clang::DeclaratorDecl* DD = nullptr; + + auto decl = DRE->getDecl(); + DD = dynamic_cast<const DeclaratorDecl*>(decl); + auto VD = dynamic_cast<const VarDecl*>(decl); + + const clang::FieldDecl* FD = nullptr; + if (nullptr != ME) { + auto member_decl = ME->getMemberDecl(); + FD = dynamic_cast<const clang::FieldDecl*>(ME->getMemberDecl()); + } + if (nullptr != FD) { + DD = FD; + } else if (nullptr != VD) { + DD = VD; + } else { + int q = 7; + } + + if (nullptr != DD) { + auto decl_source_range = nice_source_range(DD->getSourceRange(), Rewrite); + auto decl_source_location_str = decl_source_range.getBegin().printToString(*MR.SourceManager); + std::string decl_source_text; + if (decl_source_range.isValid()) { + decl_source_text = Rewrite.getRewrittenText(decl_source_range); + } else { + return; + } + QT = DD->getType(); + auto qtype_str = QT.getAsString(); + variable_name = DD->getNameAsString(); + + auto qualified_name = DD->getQualifiedNameAsString(); + static const std::string mse_namespace_str1 = "mse::"; + static const std::string mse_namespace_str2 = "::mse::"; + if ((0 == qualified_name.compare(0, mse_namespace_str1.size(), mse_namespace_str1)) + || (0 == qualified_name.compare(0, mse_namespace_str2.size(), mse_namespace_str2))) { + return; + } + + auto res1 = (*this).m_state1.m_ddecl_conversion_state_map.insert(*DD); + auto ddcs_map_iter = res1.first; + auto& ddcs_ref = (*ddcs_map_iter).second; + bool update_declaration_flag = res1.second; + + auto expr_SR = nice_source_range(CE->getSourceRange(), Rewrite); + std::string expr_source_location_str; + std::string expr_source_text; + if (expr_SR.isValid()) { + expr_source_location_str = expr_SR.getBegin().printToString(*MR.SourceManager); + expr_source_text = Rewrite.getRewrittenText(expr_SR); + } else { + int q = 3; + } + + std::vector<std::string> stmt_indirection_stack; + const clang::Expr* expr2 = populateStmtIndirectionStack(stmt_indirection_stack, *(*(CE->arg_begin()))); + std::reverse(stmt_indirection_stack.begin(), stmt_indirection_stack.end()); + stmt_indirection_stack.push_back("memset target"); + bool target_has_been_determined_to_be_an_array = false; + size_t indirection_level = 0; + if (expr2) { + std::string expr2_stmt_class_name; + expr2_stmt_class_name = expr2->getStmtClassName(); + const DeclaratorDecl* expr2_DD = nullptr; + if (clang::Stmt::StmtClass::DeclRefExprClass == expr2->getStmtClass()) { + auto expr2_DRE = llvm::cast<const clang::DeclRefExpr>(expr2); + if (expr2_DRE) { + auto expr2_decl = expr2_DRE->getDecl(); + expr2_DD = dynamic_cast<const DeclaratorDecl*>(expr2_decl); + } else { assert(false); } + } else if (clang::Stmt::StmtClass::MemberExprClass == expr2->getStmtClass()) { + auto expr2_ME = llvm::cast<const clang::MemberExpr>(expr2); + if (expr2_ME) { + auto expr2_FD = dynamic_cast<const clang::FieldDecl*>(expr2_ME->getMemberDecl()); + if (expr2_FD) { + expr2_DD = expr2_FD; + } else { assert(false); } + } else { assert(false); } + } + if (expr2_DD) { + auto expr2_QT = expr2_DD->getType(); + const clang::Type* expr2_TP = expr2_QT.getTypePtr(); + auto expr2_type_str = clang::QualType::getAsString(expr2_QT.split()); + std::string expr2_variable_name = expr2_DD->getNameAsString(); + if ((expr2_QT == QT) && (expr2_variable_name == variable_name)) { + for (size_t i = 0; ((i < ddcs_ref.m_indirection_state_stack.size()) + && (i < stmt_indirection_stack.size())); i += 1) { + if ("native pointer" == ddcs_ref.m_indirection_state_stack[i].m_current) { + if (("ArraySubscriptExpr" == stmt_indirection_stack[i]) + || ("pointer arithmetic" == stmt_indirection_stack[i])) { + ddcs_ref.m_indirection_state_stack[i].m_current = "inferred array"; + update_declaration_flag = true; + m_state1.m_array2_contingent_replacement_map.do_and_dispose_matching_replacements(m_state1, CDDeclIndirection(*DD, i)); + } else if (("memset target" == stmt_indirection_stack[i])) { + //ddcs_ref.m_indirection_state_stack[i].m_current = "memset target"; + indirection_level = i; + } + } else if (("inferred array" == ddcs_ref.m_indirection_state_stack[i].m_current) + || ("dynamic array" == ddcs_ref.m_indirection_state_stack[i].m_current) + || ("native array" == ddcs_ref.m_indirection_state_stack[i].m_current)) { + if (("memset target" == stmt_indirection_stack[i])) { + target_has_been_determined_to_be_an_array = true; + indirection_level = i; + } + } else { + int q = 5; + } + } + } else { + int q = 5; + } + } + int q = 5; + } else { + return; + } + + if (update_declaration_flag) { + update_declaration(*DD, Rewrite, m_state1); + } + + const clang::Type* arg1_TP = QT.getTypePtr(); + auto arg1_type_str = QT.getAsString(); + + std::string arg1_element_type_str; + if (arg1_TP->isArrayType()) { + auto ATP = llvm::cast<const clang::ArrayType>(arg1_TP); + assert(nullptr != ATP); + auto element_type = ATP->getElementType(); + auto elementSplitQualType = element_type.split(); + auto type_str = clang::QualType::getAsString(elementSplitQualType); + if (("char" != type_str) && ("const char" != type_str)) { + arg1_element_type_str = type_str; + } + } else if (arg1_TP->isPointerType()) { + auto TPP = llvm::cast<const clang::PointerType>(arg1_TP); + assert(nullptr != TPP); + auto target_type = TPP->getPointeeType(); + auto splitQualType = target_type.split(); + auto type_str = clang::QualType::getAsString(splitQualType); + if (("char" != type_str) && ("const char" != type_str)) { + arg1_element_type_str = type_str; + } + } + if ("" != arg1_element_type_str) { + ce_replacement_code = "for (size_t i = 0; i < (" + arg_source_text3 + + ")/sizeof(" + arg1_element_type_str + "); i += 1) { "; + ce_replacement_code += arg_source_text1 + "[i] = " + arg_source_text2 + "; "; + ce_replacement_code += "}"; + + if (ConvertToSCPP && decl_source_range.isValid() && (CESR.isValid())) { + auto cr_shptr = std::make_shared<CMemsetArray2ReplacementAction>(Rewrite, MR, CDDeclIndirection(*DD, indirection_level), CE, ce_replacement_code); + + if (target_has_been_determined_to_be_an_array) { + (*cr_shptr).do_replacement(m_state1); + } else { + m_state1.m_array2_contingent_replacement_map.insert(cr_shptr); + } + } else { + int q = 7; + } + } + } + int q = 5; + } else { + int q = 5; + } + int q = 5; + } + } + + } + } + } + +private: + Rewriter &Rewrite; + CState1& m_state1; +}; /**********************************************************************************************************************/ class MyASTConsumer : public ASTConsumer { @@ -2393,7 +2742,8 @@ class MyASTConsumer : public ASTConsumer { public: MyASTConsumer(Rewriter &R) : HandlerForSSSNativePointer(R), HandlerForSSSArrayToPointerDecay(R, m_state1), HandlerForSSSVarDecl2(R, m_state1), HandlerForSSSPointerArithmetic2(R, m_state1), HandlerForSSSMalloc2(R, m_state1), - HandlerForSSSMallocInitializer2(R, m_state1), HandlerForSSSFree2(R, m_state1), HandlerForSSSSetToNull2(R, m_state1) + HandlerForSSSMallocInitializer2(R, m_state1), HandlerForSSSFree2(R, m_state1), HandlerForSSSSetToNull2(R, m_state1), + HandlerForSSSMemset(R, m_state1) { Matcher.addMatcher(varDecl(hasType(pointerType())).bind("mcsssnativepointer"), &HandlerForSSSNativePointer); @@ -2468,6 +2818,18 @@ public: )), hasLHS(expr(hasType(pointerType()))) )).bind("mcssssettonull1"), &HandlerForSSSSetToNull2); + + Matcher.addMatcher( + callExpr(allOf( + hasAnyArgument( + expr(anyOf( + memberExpr(expr(hasDescendant(declRefExpr().bind("mcsssmemset2")))).bind("mcsssmemset3"), + hasDescendant(memberExpr(expr(hasDescendant(declRefExpr().bind("mcsssmemset2")))).bind("mcsssmemset3")), + hasDescendant(declRefExpr().bind("mcsssmemset2")) + ))), + argumentCountIs(3), + hasAnyArgument(hasType(pointerType())) + )).bind("mcsssmemset1"), &HandlerForSSSMemset); } void HandleTranslationUnit(ASTContext &Context) override @@ -2487,6 +2849,7 @@ private: MCSSSMallocInitializer2 HandlerForSSSMallocInitializer2; MCSSSFree2 HandlerForSSSFree2; MCSSSSetToNull2 HandlerForSSSSetToNull2; + MCSSSMemset HandlerForSSSMemset; MatchFinder Matcher; }; |