diff options
| -rw-r--r-- | safercpp/safercpp-arr.cpp | 448 |
1 files changed, 291 insertions, 157 deletions
diff --git a/safercpp/safercpp-arr.cpp b/safercpp/safercpp-arr.cpp index c057188..f647ed1 100644 --- a/safercpp/safercpp-arr.cpp +++ b/safercpp/safercpp-arr.cpp @@ -703,6 +703,20 @@ public: clang::QualType m_qtype; }; +class CStraightReplacementExprTextModifier : public CExprTextModifier { +public: + CStraightReplacementExprTextModifier(const std::string& replacement_text) : + m_replacement_text(replacement_text) {} + virtual ~CStraightReplacementExprTextModifier() {} + virtual std::string modified_copy(const std::string& input_text, const clang::Expr* expr_ptr = nullptr) const { + return m_replacement_text; + } + virtual std::string species_str() const { + return "straight replacement"; + } + std::string m_replacement_text; +}; + class CExprTextModifierStack : public std::vector<std::shared_ptr<CExprTextModifier>> { public: }; @@ -777,23 +791,83 @@ public: return (*(static_cast<const clang::ConditionalOperator *>(m_expr_cptr))); } virtual void update_current_text() { - if (false) { + if (true) { /* Do we need to update the kids first? */ - m_cond_shptr->update_current_text(); - m_lhs_shptr->update_current_text(); - m_rhs_shptr->update_current_text(); + cond_shptr()->update_current_text(); + lhs_shptr()->update_current_text(); + rhs_shptr()->update_current_text(); } - std::string updated_text = m_cond_shptr->m_current_text_str + " ? " - + m_lhs_shptr->m_current_text_str + " : " + m_rhs_shptr->m_current_text_str; + std::string updated_text = cond_shptr()->m_current_text_str + " ? " + + lhs_shptr()->m_current_text_str + " : " + rhs_shptr()->m_current_text_str; updated_text = modified_copy(updated_text); m_current_text_str = updated_text; } + std::shared_ptr<CExprConversionState>& cond_shptr() { + if (3 != m_children_shptrs.size()) { + assert(false); + return m_cond_shptr; + } else { + return m_children_shptrs[0]; + } + } + std::shared_ptr<CExprConversionState>& lhs_shptr() { + if (3 != m_children_shptrs.size()) { + assert(false); + return m_lhs_shptr; + } else { + return m_children_shptrs[1]; + } + } + std::shared_ptr<CExprConversionState>& rhs_shptr() { + if (3 != m_children_shptrs.size()) { + assert(false); + return m_rhs_shptr; + } else { + return m_children_shptrs[2]; + } + } + +private: std::shared_ptr<CExprConversionState> m_cond_shptr; std::shared_ptr<CExprConversionState> m_lhs_shptr; std::shared_ptr<CExprConversionState> m_rhs_shptr; }; +class CAddressofArraySubscriptExprConversionState : public CExprConversionState { +public: + CAddressofArraySubscriptExprConversionState(const clang::UnaryOperator& addrofexpr_cref, Rewriter &Rewrite, const clang::ArraySubscriptExpr& arraysubscriptexpr_cref) : CExprConversionState(addrofexpr_cref, Rewrite), m_arraysubscriptexpr_cptr(&arraysubscriptexpr_cref) { + assert(clang::UnaryOperatorKind::UO_AddrOf == addrofexpr_cref.getOpcode()); + m_arraysubscriptexpr_shptr = std::make_shared<CExprConversionState>(*m_arraysubscriptexpr_cptr, Rewrite); + m_children_shptrs.push_back(m_arraysubscriptexpr_shptr); + } + const clang::UnaryOperator& addrofexpr_cref() const { + return (*(static_cast<const clang::UnaryOperator *>(m_expr_cptr))); + } + virtual void update_current_text() { + if (true) { + /* Do we need to update the kids first? */ + arraysubscriptexpr_shptr()->update_current_text(); + } + std::string updated_text = "&(" + arraysubscriptexpr_shptr()->m_current_text_str + ")"; + updated_text = modified_copy(updated_text); + m_current_text_str = updated_text; + } + + std::shared_ptr<CExprConversionState>& arraysubscriptexpr_shptr() { + if (1 != m_children_shptrs.size()) { + assert(false); + return m_arraysubscriptexpr_shptr; + } else { + return m_children_shptrs[0]; + } + } + +private: + std::shared_ptr<CExprConversionState> m_arraysubscriptexpr_shptr; + const clang::ArraySubscriptExpr* m_arraysubscriptexpr_cptr = nullptr; +}; + template<class X, class... Args> std::shared_ptr<X> make_expr_conversion_state_shared_ptr(Args&&... args) { std::shared_ptr<X> retval = std::make_shared<X>(std::forward<Args>(args)...); @@ -807,13 +881,21 @@ public: iterator insert( const std::shared_ptr<CExprConversionState>& cr_shptr ) { iterator retval(end()); if (!cr_shptr) { assert(false); } else { + decltype((*cr_shptr).m_children_shptrs) mapped_children_shptrs; + for (auto& child_shptr_ref : (*cr_shptr).m_children_shptrs) { + //value_type val((*child_shptr_ref).m_expr_cptr, child_shptr_ref); + //auto res2 = base_class::insert(val); + auto iter1 = insert(child_shptr_ref); + if (child_shptr_ref != (*iter1).second) { + int q = 7; + } + mapped_children_shptrs.push_back((*iter1).second); + } + value_type val((*cr_shptr).m_expr_cptr, cr_shptr); auto res1 = base_class::insert(val); retval = res1.first; - for (auto& child_shptr_ref : (*cr_shptr).m_children_shptrs) { - value_type val((*child_shptr_ref).m_expr_cptr, child_shptr_ref); - auto res1 = base_class::insert(val); - } + (*((*retval).second)).m_children_shptrs = mapped_children_shptrs; } return retval; } @@ -932,6 +1014,19 @@ public: const CDDeclIndirection m_ddecl_indirection2; }; +class CAssignmentTargetConstrainsAddressofArraySubscriptExprArray2ReplacementAction : public CArray2ReplacementAction { +public: + CAssignmentTargetConstrainsAddressofArraySubscriptExprArray2ReplacementAction(Rewriter &Rewrite, const MatchFinder::MatchResult &MR, const CDDeclIndirection& ddecl_indirection, + const clang::UnaryOperator& addrofexpr_cref, const clang::ArraySubscriptExpr& arraysubscriptexpr_cref) : + CArray2ReplacementAction(Rewrite, MR, ddecl_indirection), m_addrofexpr_cptr(&addrofexpr_cref), m_arraysubscriptexpr_cptr(&arraysubscriptexpr_cref) {} + virtual ~CAssignmentTargetConstrainsAddressofArraySubscriptExprArray2ReplacementAction() {} + + virtual void do_replacement(CState1& state1) const; + + const clang::UnaryOperator* m_addrofexpr_cptr = nullptr; + const clang::ArraySubscriptExpr* m_arraysubscriptexpr_cptr = nullptr; +}; + class CDDecl2ReplacementActionMap : public std::multimap<CDDeclIndirection, std::shared_ptr<CDDecl2ReplacementAction>> { public: typedef std::multimap<CDDeclIndirection, std::shared_ptr<CDDecl2ReplacementAction>> base_class; @@ -1929,6 +2024,47 @@ void CSameTypeArray2ReplacementAction::do_replacement(CState1& state1) const { } } +void CAssignmentTargetConstrainsAddressofArraySubscriptExprArray2ReplacementAction::do_replacement(CState1& state1) const { + Rewriter &Rewrite = m_Rewrite; + const MatchFinder::MatchResult &MR = m_MR; + + const clang::UnaryOperator* UO = m_addrofexpr_cptr; + const ArraySubscriptExpr* ASE = m_arraysubscriptexpr_cptr; + if (UO && ASE) { + auto UOSR = nice_source_range(UO->getSourceRange(), (*this).m_Rewrite); + auto ase_SR = nice_source_range(ASE->getSourceRange(), (*this).m_Rewrite); + if ((UOSR.isValid()) && (ase_SR.isValid())) { + auto uocs_iter = state1.m_expr_conversion_state_map.find(UO); + if (state1.m_expr_conversion_state_map.end() == uocs_iter) { + std::shared_ptr<CExprConversionState> shptr1 = make_expr_conversion_state_shared_ptr<CAddressofArraySubscriptExprConversionState>(*UO, m_Rewrite, *ASE); + uocs_iter = state1.m_expr_conversion_state_map.insert(shptr1); + } + auto& uocs_shptr_ref = (*uocs_iter).second; + + auto index_expr_cptr = ASE->getIdx(); + auto array_expr_cptr = ASE->getBase(); + if (index_expr_cptr && array_expr_cptr) { + auto index_expr_SR = nice_source_range(index_expr_cptr->getSourceRange(), (*this).m_Rewrite); + auto array_expr_SR = nice_source_range(array_expr_cptr->getSourceRange(), (*this).m_Rewrite); + if (index_expr_SR.isValid() && array_expr_SR.isValid()) { + std::string index_expr_text = (*this).m_Rewrite.getRewrittenText(index_expr_SR); + std::string array_expr_text = (*this).m_Rewrite.getRewrittenText(array_expr_SR); + + std::string UO_replacement_text = "((" + array_expr_text + ") + (" + index_expr_text + "))"; + if (ConvertToSCPP) { + std::shared_ptr<CExprTextModifier> shptr1 = std::make_shared<CStraightReplacementExprTextModifier>(UO_replacement_text); + (*uocs_shptr_ref).m_expr_text_modifier_stack.push_back(shptr1); + (*uocs_shptr_ref).update_current_text(); + + (*this).m_Rewrite.ReplaceText(UOSR, (*uocs_shptr_ref).m_current_text_str); + } + } + } + + } + } +} + void CConditionalOperatorReconciliation2ReplacementAction::do_replacement(CState1& state1) const { const clang::ConditionalOperator* CO = m_CO; const Expr* COND = nullptr; @@ -2044,6 +2180,8 @@ void CConditionalOperatorReconciliation2ReplacementAction::do_replacement(CState (*lhscs_shptr_ref).m_expr_text_modifier_stack.push_back(shptr1); (*lhscs_shptr_ref).update_current_text(); } + } else { + int q = 7; } } if (rhs_needs_to_be_wrapped) { @@ -2063,6 +2201,8 @@ void CConditionalOperatorReconciliation2ReplacementAction::do_replacement(CState (*rhscs_shptr_ref).m_expr_text_modifier_stack.push_back(shptr1); (*rhscs_shptr_ref).update_current_text(); } + } else { + int q = 7; } } @@ -2076,6 +2216,8 @@ void CConditionalOperatorReconciliation2ReplacementAction::do_replacement(CState auto& ddcs_ref = (*ddcs_map_iter).second; ddcs_ref.m_initializer_info_str = " = " + cocs_shptr_ref.m_current_text_str; + + update_declaration(*m_var_DD, m_Rewrite, state1); } } @@ -2086,6 +2228,7 @@ void CConditionalOperatorReconciliation2ReplacementAction::do_replacement(CState struct CLeadingAddressofOperatorInfo { bool leading_addressof_operator_detected = false; const clang::Expr* without_leading_addressof_operator_expr_cptr = nullptr; + const clang::UnaryOperator* addressof_unary_operator_cptr = nullptr; }; CLeadingAddressofOperatorInfo leading_addressof_operator_info_from_stmt(const clang::Stmt& stmt_cref, int depth = 0) { CLeadingAddressofOperatorInfo retval; @@ -2098,6 +2241,7 @@ CLeadingAddressofOperatorInfo leading_addressof_operator_info_from_stmt(const cl if (UO) { if (clang::UnaryOperatorKind::UO_AddrOf == UO->getOpcode()) { retval.leading_addressof_operator_detected = true; + retval.addressof_unary_operator_cptr = UO; auto child_iter = ST->child_begin(); if (child_iter != ST->child_end()) { @@ -2624,9 +2768,6 @@ public: } else { return; } - if (std::string::npos != source_location_str.find("526")) { - int q = 5; - } if (filtered_out_by_location(MR, BOSL)) { return void(); @@ -2761,15 +2902,14 @@ public: } const clang::Type* lhs_TP = lhs_QT.getTypePtr(); - auto lhs_type_str = clang::QualType::getAsString(lhs_QT.split()); + auto lhs_type_str = lhs_QT.getAsString(); std::string lhs_element_type_str; if (lhs_TP->isArrayType()) { auto ATP = llvm::cast<const clang::ArrayType>(lhs_TP); assert(nullptr != ATP); auto element_type = ATP->getElementType(); - auto elementSplitQualType = element_type.split(); - auto type_str = clang::QualType::getAsString(elementSplitQualType); + auto type_str = element_type.getAsString(); if (("char" != type_str) && ("const char" != type_str)) { lhs_element_type_str = type_str; } @@ -2777,8 +2917,7 @@ public: auto TPP = llvm::cast<const clang::PointerType>(lhs_TP); assert(nullptr != TPP); auto target_type = TPP->getPointeeType(); - auto splitQualType = target_type.split(); - auto type_str = clang::QualType::getAsString(splitQualType); + auto type_str = target_type.getAsString(); if (("char" != type_str) && ("const char" != type_str)) { lhs_element_type_str = type_str; } @@ -2873,6 +3012,10 @@ public: return void(); } + if (std::string::npos != source_location_str.find("288")) { + int q = 5; + } + auto function_decl = CE->getDirectCallee(); auto num_args = CE->getNumArgs(); if (function_decl && ((1 == num_args) || (2 == num_args))) { @@ -2993,14 +3136,15 @@ public: auto ATP = llvm::cast<const clang::ArrayType>(TP); assert(nullptr != ATP); auto element_type = ATP->getElementType(); - auto elementSplitQualType = element_type.split(); - element_type_str = clang::QualType::getAsString(elementSplitQualType); + auto type_str = element_type.getAsString(); + if (("char" != type_str) && ("const char" != type_str)) { + element_type_str = type_str; + } } else if (TP->isPointerType()) { auto TPP = llvm::cast<const clang::PointerType>(TP); assert(nullptr != TPP); auto target_type = TPP->getPointeeType(); - auto splitQualType = target_type.split(); - auto type_str = clang::QualType::getAsString(splitQualType); + auto type_str = target_type.getAsString(); if (("char" != type_str) && ("const char" != type_str)) { element_type_str = type_str; } @@ -3105,35 +3249,23 @@ public: bool ends_with_free = ((lc_function_name.size() >= free_str.size()) && (0 == lc_function_name.compare(lc_function_name.size() - free_str.size(), free_str.size(), free_str))); if (ends_with_free) { - auto iter = CE->arg_begin(); - assert((*iter)->getType().getTypePtrOrNull()); - auto arg_source_range = nice_source_range((*iter)->getSourceRange(), Rewrite); + auto arg_iter = CE->arg_begin(); + assert((*arg_iter)->getType().getTypePtrOrNull()); + auto arg_source_range = nice_source_range((*arg_iter)->getSourceRange(), Rewrite); std::string arg_source_text; if (arg_source_range.isValid()) { arg_source_text = Rewrite.getRewrittenText(arg_source_range); //auto arg_source_text_sans_ws = with_whitespace_removed(arg_source_text); + 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); + auto res2 = infer_array_type_info_from_stmt(*(*(CE->arg_begin())), "malloc target", (*this).m_state1); + auto DD = res2.ddecl_cptr; - 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 (res2.update_declaration_flag) { + update_declaration(*DD, Rewrite, m_state1); } if (nullptr != DD) { @@ -3156,26 +3288,44 @@ public: return; } - auto res2 = infer_array_type_info_from_stmt(*(*(CE->arg_begin())), "malloc target", (*this).m_state1, DD); + const clang::Type* TP = QT.getTypePtr(); + auto type_str = QT.getAsString(); - if (res2.update_declaration_flag) { - update_declaration(*DD, Rewrite, m_state1); + std::string element_type_str; + if (TP->isArrayType()) { + auto ATP = llvm::cast<const clang::ArrayType>(TP); + assert(nullptr != ATP); + auto element_type = ATP->getElementType(); + auto type_str = element_type.getAsString(); + if (("char" != type_str) && ("const char" != type_str)) { + element_type_str = type_str; + } + } else if (TP->isPointerType()) { + auto TPP = llvm::cast<const clang::PointerType>(TP); + assert(nullptr != TPP); + auto target_type = TPP->getPointeeType(); + auto type_str = target_type.getAsString(); + if (("char" != type_str) && ("const char" != type_str)) { + element_type_str = type_str; + } } - ce_replacement_code = "(" + arg_source_text + ")"; - ce_replacement_code += ".resize(0)"; + if ("" != element_type_str) { + ce_replacement_code = "(" + arg_source_text + ")"; + ce_replacement_code += ".resize(0)"; - if (ConvertToSCPP && decl_source_range.isValid() && (CESR.isValid()) - && (nullptr != res2.ddecl_conversion_state_ptr)) { - auto cr_shptr = std::make_shared<CFreeDynamicArray2ReplacementAction>(Rewrite, MR, CDDeclIndirection(*DD, res2.indirection_level), CE, ce_replacement_code); + if (ConvertToSCPP && decl_source_range.isValid() && (CESR.isValid()) + && (nullptr != res2.ddecl_conversion_state_ptr)) { + auto cr_shptr = std::make_shared<CFreeDynamicArray2ReplacementAction>(Rewrite, MR, CDDeclIndirection(*(res2.ddecl_cptr), res2.indirection_level), CE, ce_replacement_code); - if ((*(res2.ddecl_conversion_state_ptr)).has_been_determined_to_be_an_array(res2.indirection_level)) { - (*cr_shptr).do_replacement(m_state1); + if ((*(res2.ddecl_conversion_state_ptr)).has_been_determined_to_be_an_array(res2.indirection_level)) { + (*cr_shptr).do_replacement(m_state1); + } else { + m_state1.m_dynamic_array2_contingent_replacement_map.insert(cr_shptr); + } } else { - m_state1.m_dynamic_array2_contingent_replacement_map.insert(cr_shptr); + int q = 7; } - } else { - int q = 7; } } int q = 5; @@ -3244,72 +3394,49 @@ public: lhs_source_text = Rewrite.getRewrittenText(lhs_source_range); //auto lhs_source_text_sans_ws = with_whitespace_removed(lhs_source_text); - QualType QT; - std::string element_type_str; - clang::SourceRange decl_source_range; - std::string variable_name; - std::string bo_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; + auto lhs_res2 = infer_array_type_info_from_stmt(*LHS, "set to null", (*this).m_state1); + bool lhs_is_an_indirect_type = is_an_indirect_type(LHS->getType()); + + if (lhs_res2.update_declaration_flag) { + update_declaration(*(lhs_res2.ddecl_cptr), Rewrite, m_state1); } - 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(); - 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 lhs_QT = LHS->getType(); + const clang::Type* lhs_TP = lhs_QT.getTypePtr(); + auto lhs_type_str = lhs_QT.getAsString(); + + std::string lhs_element_type_str; + if (lhs_TP->isArrayType()) { + auto ATP = llvm::cast<const clang::ArrayType>(lhs_TP); + assert(nullptr != ATP); + auto element_type = ATP->getElementType(); + auto type_str = element_type.getAsString(); + if (("char" != type_str) && ("const char" != type_str)) { + lhs_element_type_str = type_str; } - - auto res2 = infer_array_type_info_from_stmt(*LHS, "set to null", (*this).m_state1, DD); - - if (res2.update_declaration_flag) { - update_declaration(*DD, Rewrite, m_state1); + } else if (lhs_TP->isPointerType()) { + auto TPP = llvm::cast<const clang::PointerType>(lhs_TP); + assert(nullptr != TPP); + auto target_type = TPP->getPointeeType(); + auto type_str = target_type.getAsString(); + if (("char" != type_str) && ("const char" != type_str)) { + lhs_element_type_str = type_str; } + } - auto lhs_source_range = nice_source_range(LHS->getSourceRange(), Rewrite); - auto lhs_source_text = Rewrite.getRewrittenText(lhs_source_range); - bo_replacement_code += "(" + lhs_source_text + ")"; - bo_replacement_code += ".resize(0)"; + if ("" != lhs_element_type_str) { + if (ConvertToSCPP && (lhs_res2.ddecl_conversion_state_ptr) && lhs_is_an_indirect_type) { + auto lhs_source_text = Rewrite.getRewrittenText(lhs_source_range); + std::string bo_replacement_code = "(" + lhs_source_text + ")"; + bo_replacement_code += ".resize(0)"; - if (ConvertToSCPP && decl_source_range.isValid() && (BOSR.isValid()) - && (nullptr != res2.ddecl_conversion_state_ptr)) { - auto cr_shptr = std::make_shared<CSetArrayPointerToNull2ReplacementAction>(Rewrite, MR, CDDeclIndirection(*DD, res2.indirection_level), BO, bo_replacement_code); + auto cr_shptr = std::make_shared<CSetArrayPointerToNull2ReplacementAction>(Rewrite, MR, CDDeclIndirection(*(lhs_res2.ddecl_cptr), lhs_res2.indirection_level), BO, bo_replacement_code); - if ((*(res2.ddecl_conversion_state_ptr)).has_been_determined_to_be_an_array(res2.indirection_level)) { + if ((*(lhs_res2.ddecl_conversion_state_ptr)).has_been_determined_to_be_an_array(lhs_res2.indirection_level)) { (*cr_shptr).do_replacement(m_state1); } else { m_state1.m_dynamic_array2_contingent_replacement_map.insert(cr_shptr); } - } else { - int q = 7; } } int q = 5; @@ -3448,8 +3575,7 @@ public: 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); + auto type_str = element_type.getAsString(); if (("char" != type_str) && ("const char" != type_str)) { arg1_element_type_str = type_str; } @@ -3457,8 +3583,7 @@ public: 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); + auto type_str = target_type.getAsString(); if (("char" != type_str) && ("const char" != type_str)) { arg1_element_type_str = type_str; } @@ -3627,8 +3752,7 @@ public: 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); + auto type_str = element_type.getAsString(); if (("char" != type_str) && ("const char" != type_str)) { arg1_element_type_str = type_str; } @@ -3636,8 +3760,7 @@ public: 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); + auto type_str = target_type.getAsString(); if (("char" != type_str) && ("const char" != type_str)) { arg1_element_type_str = type_str; } @@ -4126,12 +4249,6 @@ public: if (ends_with_free || ends_with_alloc || ends_with_realloc || is_memcpy || is_memset || begins_with__builtin_) { return void(); } - if ("lodepng_deflate" == function_name) { - int q = 5; - } - if ("deflate" == function_name) { - int q = 5; - } auto function_decls_range = function_decl1->redecls(); @@ -4155,11 +4272,34 @@ public: bool rhs_is_an_indirect_type = is_an_indirect_type(arg_EX->getType()); assert(lhs_is_an_indirect_type == rhs_is_an_indirect_type); + auto res1 = m_state1.m_ddecl_conversion_state_map.insert(*param_VD); + auto ddcs_map_iter = res1.first; + auto& ddcs_ref = (*ddcs_map_iter).second; + bool update_declaration_flag = res1.second; + size_t lhs_indirection_level_adjustment = 0; auto rhs_res3 = leading_addressof_operator_info_from_stmt(*arg_EX); if (rhs_res3.without_leading_addressof_operator_expr_cptr) { + assert(rhs_res3.leading_addressof_operator_detected && rhs_res3.addressof_unary_operator_cptr); + arg_EX = rhs_res3.without_leading_addressof_operator_expr_cptr; lhs_indirection_level_adjustment = 1; + + const clang::ArraySubscriptExpr* array_subscript_expr_cptr = nullptr; + if (clang::Stmt::StmtClass::ArraySubscriptExprClass == (*(rhs_res3.without_leading_addressof_operator_expr_cptr)).getStmtClass()) { + assert(llvm::isa<const clang::ArraySubscriptExpr>(rhs_res3.without_leading_addressof_operator_expr_cptr)); + array_subscript_expr_cptr = llvm::cast<const clang::ArraySubscriptExpr>(rhs_res3.without_leading_addressof_operator_expr_cptr); + } + if (array_subscript_expr_cptr) { + std::shared_ptr<CArray2ReplacementAction> cr_shptr = std::make_shared<CAssignmentTargetConstrainsAddressofArraySubscriptExprArray2ReplacementAction>(Rewrite, MR, + CDDeclIndirection(*param_VD, 0), *(rhs_res3.addressof_unary_operator_cptr), *array_subscript_expr_cptr); + + if (ddcs_ref.has_been_determined_to_be_an_array(0)) { + (*cr_shptr).do_replacement(m_state1); + } else { + m_state1.m_array2_contingent_replacement_map.insert(cr_shptr); + } + } } auto rhs_res2 = infer_array_type_info_from_stmt(*arg_EX, "", (*this).m_state1); @@ -4217,11 +4357,6 @@ public: } } - auto res1 = m_state1.m_ddecl_conversion_state_map.insert(*param_VD); - auto ddcs_map_iter = res1.first; - auto& ddcs_ref = (*ddcs_map_iter).second; - bool update_declaration_flag = res1.second; - if (ddcs_ref.m_ddecl_cptr && update_declaration_flag) { update_declaration(*(ddcs_ref.m_ddecl_cptr), Rewrite, m_state1); } @@ -4243,6 +4378,8 @@ public: cr_shptr = std::make_shared<CAssignmentTargetConstrainsSourceArray2ReplacementAction>(Rewrite, MR, CDDeclIndirection(*param_VD, i + lhs_indirection_level_adjustment), CDDeclIndirection(*(rhs_res2.ddecl_cptr), rhs_res2.indirection_level + i)); } else { + /* Levels of indirection beyond the first one must be of the same type, + * not just of "compatible" types. */ cr_shptr = std::make_shared<CSameTypeArray2ReplacementAction>(Rewrite, MR, CDDeclIndirection(*param_VD, i + lhs_indirection_level_adjustment), CDDeclIndirection(*(rhs_res2.ddecl_cptr), rhs_res2.indirection_level + i)); } @@ -4264,8 +4401,8 @@ public: cr_shptr = std::make_shared<CAssignmentSourceConstrainsTargetArray2ReplacementAction>(Rewrite, MR, CDDeclIndirection(*(rhs_res2.ddecl_cptr), rhs_res2.indirection_level + i), CDDeclIndirection(*param_VD, i + lhs_indirection_level_adjustment)); } else { - /* This is actually redundant since we decided to make CSameTypeArray2ReplacementAction - * apply the constraint in both directions already. But the redundancy doesn't hurt. */ + /* Levels of indirection beyond the first one must be of the same type, + * not just of "compatible" types. */ cr_shptr = std::make_shared<CSameTypeArray2ReplacementAction>(Rewrite, MR, CDDeclIndirection(*(rhs_res2.ddecl_cptr), rhs_res2.indirection_level + i), CDDeclIndirection(*param_VD, i + lhs_indirection_level_adjustment)); } @@ -4429,8 +4566,8 @@ public: Matcher.addMatcher(clang::ast_matchers::declaratorDecl().bind("mcsssvardecl"), &HandlerForSSSVarDecl2); Matcher.addMatcher(expr(allOf( - hasParent(expr(anyOf( \ - unaryOperator(hasOperatorName("++")), unaryOperator(hasOperatorName("--")), \ + hasParent(expr(anyOf( + unaryOperator(hasOperatorName("++")), unaryOperator(hasOperatorName("--")), binaryOperator(hasOperatorName("+=")), binaryOperator(hasOperatorName("-=")), castExpr(hasParent(expr(anyOf( binaryOperator(hasOperatorName("+")), binaryOperator(hasOperatorName("+=")), @@ -4452,36 +4589,34 @@ public: hasOperatorName("="), hasRHS( anyOf( - cStyleCastExpr(has(callExpr().bind("mcsssmalloc2"))), - callExpr().bind("mcsssmalloc2") + cStyleCastExpr(has(ignoringParenCasts(callExpr().bind("mcsssmalloc2")))), + ignoringParenCasts(callExpr().bind("mcsssmalloc2")) ) ), - hasLHS(anyOf( - memberExpr(expr(hasDescendant(declRefExpr().bind("mcsssmalloc3")))).bind("mcsssmalloc4"), + hasLHS(ignoringParenCasts(anyOf( + memberExpr(expr(hasDescendant(declRefExpr().bind("mcsssmalloc3")))).bind("mcsssmalloc4"), declRefExpr().bind("mcsssmalloc3"), hasDescendant(memberExpr(expr(hasDescendant(declRefExpr().bind("mcsssmalloc3")))).bind("mcsssmalloc4")), hasDescendant(declRefExpr().bind("mcsssmalloc3")) - )), + ))), hasLHS(expr(hasType(pointerType()))) )).bind("mcsssmalloc1"), &HandlerForSSSMalloc2); Matcher.addMatcher(declStmt(hasDescendant( - varDecl(hasInitializer(ignoringImpCasts( - anyOf( - cStyleCastExpr(has(callExpr().bind("mcsssmallocinitializer2"))), + varDecl(hasInitializer(ignoringParenCasts( callExpr().bind("mcsssmallocinitializer2") - ) ))).bind("mcsssmallocinitializer3") )).bind("mcsssmallocinitializer1"), &HandlerForSSSMallocInitializer2); Matcher.addMatcher( callExpr(allOf( - hasAnyArgument( + hasAnyArgument(ignoringParenCasts( expr(anyOf( memberExpr(expr(hasDescendant(declRefExpr().bind("mcsssfree2")))).bind("mcsssfree3"), + declRefExpr().bind("mcsssfree2"), hasDescendant(memberExpr(expr(hasDescendant(declRefExpr().bind("mcsssfree2")))).bind("mcsssfree3")), hasDescendant(declRefExpr().bind("mcsssfree2")) - ))), + )))), argumentCountIs(1), hasAnyArgument(hasType(pointerType())) )).bind("mcsssfree1"), &HandlerForSSSFree2); @@ -4489,9 +4624,8 @@ public: Matcher.addMatcher(binaryOperator(allOf( hasOperatorName("="), hasLHS(anyOf( - memberExpr(expr(hasDescendant(declRefExpr().bind("mcssssettonull3")))).bind("mcssssettonull4"), - hasDescendant(memberExpr(expr(hasDescendant(declRefExpr().bind("mcssssettonull3")))).bind("mcssssettonull4")), - hasDescendant(declRefExpr().bind("mcssssettonull3")) + ignoringParenCasts(declRefExpr().bind("mcssssettonull3")), + ignoringParenCasts(expr(hasDescendant(declRefExpr().bind("mcssssettonull3")))) )), hasLHS(expr(hasType(pointerType()))) )).bind("mcssssettonull1"), &HandlerForSSSSetToNull2); @@ -4499,11 +4633,12 @@ public: Matcher.addMatcher( callExpr(allOf( hasAnyArgument( - expr(anyOf( - memberExpr(expr(hasDescendant(declRefExpr().bind("mcsssmemset2")))).bind("mcsssmemset3"), + ignoringParenCasts(expr(anyOf( + memberExpr(expr(hasDescendant(declRefExpr().bind("mcsssmemset2")))).bind("mcsssmemset3"), + declRefExpr().bind("mcsssmemset2"), hasDescendant(memberExpr(expr(hasDescendant(declRefExpr().bind("mcsssmemset2")))).bind("mcsssmemset3")), hasDescendant(declRefExpr().bind("mcsssmemset2")) - ))), + )))), argumentCountIs(3), hasAnyArgument(hasType(pointerType())) )).bind("mcsssmemset1"), &HandlerForSSSMemset); @@ -4511,22 +4646,21 @@ public: Matcher.addMatcher( callExpr(allOf( hasAnyArgument( - expr(anyOf( - memberExpr(expr(hasDescendant(declRefExpr().bind("mcsssmemcpy2")))).bind("mcsssmemcpy3"), + ignoringParenCasts(expr(anyOf( + memberExpr(expr(hasDescendant(declRefExpr().bind("mcsssmemcpy2")))).bind("mcsssmemcpy3"), + declRefExpr().bind("mcsssmemcpy2"), hasDescendant(memberExpr(expr(hasDescendant(declRefExpr().bind("mcsssmemcpy2")))).bind("mcsssmemcpy3")), hasDescendant(declRefExpr().bind("mcsssmemcpy2")) - ))), + )))), argumentCountIs(3), hasAnyArgument(hasType(pointerType())) )).bind("mcsssmemcpy1"), &HandlerForSSSMemcpy); Matcher.addMatcher(declStmt(hasDescendant( - varDecl(hasInitializer(ignoringImpCasts( + varDecl(hasInitializer(ignoringParenCasts( anyOf( conditionalOperator(has(declRefExpr())).bind("mcsssconditionalinitializer2"), - conditionalOperator(hasDescendant(declRefExpr())).bind("mcsssconditionalinitializer2"), - cStyleCastExpr(has(conditionalOperator(has(declRefExpr())).bind("mcsssconditionalinitializer2"))), - cStyleCastExpr(has(conditionalOperator(hasDescendant(declRefExpr())).bind("mcsssconditionalinitializer2"))) + conditionalOperator(hasDescendant(declRefExpr())).bind("mcsssconditionalinitializer2") ) ))).bind("mcsssconditionalinitializer3") )).bind("mcsssconditionalinitializer1"), &HandlerForSSSConditionalInitializer); |