From 299d532dbf3966259a3911a735c5f29ac835c2cc Mon Sep 17 00:00:00 2001 From: duneroadrunner Date: Sat, 17 Jun 2017 10:47:17 -0700 Subject: updated so that processing of declarations with initializers can handle all the same cases as the processing of assignment operations --- safercpp/safercpp-arr.cpp | 379 ++++++++++++++++++++++++++++++++-------------- 1 file changed, 269 insertions(+), 110 deletions(-) (limited to 'safercpp') diff --git a/safercpp/safercpp-arr.cpp b/safercpp/safercpp-arr.cpp index f7644a1..e0f51db 100644 --- a/safercpp/safercpp-arr.cpp +++ b/safercpp/safercpp-arr.cpp @@ -1386,6 +1386,7 @@ class CTypeIndirectionPrefixAndSuffixItem { public: std::string m_prefix_str; std::string m_suffix_str; + std::string m_post_name_suffix_str; std::string m_action_species; bool m_direct_type_must_be_non_const = false; }; @@ -1398,6 +1399,7 @@ static CTypeIndirectionPrefixAndSuffixItem generate_type_indirection_prefix_and_ std::string replacement_code; std::string prefix_str; std::string suffix_str; + std::string post_name_suffix_str; if (true) { for (size_t i = 0; i < indirection_state_stack.size(); i += 1) { @@ -1458,7 +1460,11 @@ static CTypeIndirectionPrefixAndSuffixItem generate_type_indirection_prefix_and_ /* We're assuming this is a null terminated string. We'll just leave it as a * char[] for now. At some point we'll replace it with an mse::string or whatever. */ //prefix_str = prefix_str + ""; - suffix_str = "[" + size_text + "]" + suffix_str; + if (1 == indirection_state_stack.size()) { + post_name_suffix_str = post_name_suffix_str + "[" + size_text + "]"; + } else { + suffix_str = "[" + size_text + "]" + suffix_str; + } } else { if (is_a_function_parameter) { prefix_str = prefix_str + "mse::TNullableAnyRandomAccessIterator<"; @@ -1700,6 +1706,7 @@ static CDeclarationReplacementCodeItem generate_declaration_replacement_code(con std::string replacement_code; std::string prefix_str; std::string suffix_str; + std::string post_name_suffix_str; auto res4 = generate_type_indirection_prefix_and_suffix(ddcs_ref.m_indirection_state_stack, direct_type_is_char_type, direct_type_is_function_type, is_a_function_parameter); @@ -1710,6 +1717,7 @@ static CDeclarationReplacementCodeItem generate_declaration_replacement_code(con } prefix_str = res4.m_prefix_str; suffix_str = res4.m_suffix_str; + post_name_suffix_str = res4.m_post_name_suffix_str; bool discard_initializer_option_flag = (std::string::npos != options_str.find("[discard-initializer]")); std::string initializer_append_str; @@ -1720,7 +1728,7 @@ static CDeclarationReplacementCodeItem generate_declaration_replacement_code(con } } - if (("" != prefix_str) || ("" != suffix_str)) { + if (("" != prefix_str) || ("" != suffix_str)/* || ("" != post_name_suffix_str)*/) { changed_from_original = true; } else if (("" != ddcs_ref.m_initializer_info_str) || (discard_initializer_option_flag)) { @@ -1751,6 +1759,7 @@ static CDeclarationReplacementCodeItem generate_declaration_replacement_code(con replacement_code += prefix_str + direct_qtype_str + suffix_str; replacement_code += " "; replacement_code += variable_name; + replacement_code += post_name_suffix_str; replacement_code += initializer_append_str; } else { @@ -2954,6 +2963,102 @@ private: /**********************************************************************************************************************/ +struct CAllocFunctionInfo { + bool m_seems_to_be_some_kind_of_malloc_or_realloc = false; + bool m_seems_to_be_some_kind_of_realloc = false; + clang::CallExpr::const_arg_iterator m_num_bytes_arg_iter; + std::string m_num_bytes_arg_source_text; +}; +CAllocFunctionInfo analyze_malloc_resemblance(const clang::CallExpr& call_expr, Rewriter &Rewrite) { + CAllocFunctionInfo retval; + + auto CE = &call_expr; + auto function_decl = CE->getDirectCallee(); + auto num_args = CE->getNumArgs(); + if (function_decl && ((1 == num_args) || (2 == num_args))) { + std::string function_name = function_decl->getNameAsString(); + static const std::string alloc_str = "alloc"; + static const std::string realloc_str = "realloc"; + auto lc_function_name = tolowerstr(function_name); + bool ends_with_alloc = ((lc_function_name.size() >= alloc_str.size()) + && (0 == lc_function_name.compare(lc_function_name.size() - alloc_str.size(), alloc_str.size(), alloc_str))); + bool ends_with_realloc = (ends_with_alloc && (lc_function_name.size() >= realloc_str.size()) + && (0 == lc_function_name.compare(lc_function_name.size() - realloc_str.size(), realloc_str.size(), realloc_str))); + bool still_potentially_valid1 = (ends_with_alloc && (1 == num_args)) || (ends_with_realloc && (2 == num_args)); + if (still_potentially_valid1) { + auto arg_iter = CE->arg_begin(); + if (ends_with_realloc) { + arg_iter++; + } + bool argIsIntegerType = false; + if (*arg_iter) { + argIsIntegerType = (*arg_iter)->getType().split().asPair().first->isIntegerType(); + } + if (argIsIntegerType) { + 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); + + bool asterisk_found = false; + auto sizeof_start_index = arg_source_text.find("sizeof("); + if (std::string::npos != sizeof_start_index) { + auto sizeof_end_index = arg_source_text.find(")", sizeof_start_index); + if (std::string::npos != sizeof_end_index) { + assert(sizeof_end_index > sizeof_start_index); + std::string before_str = arg_source_text.substr(0, sizeof_start_index); + std::string after_str; + if (sizeof_end_index + 1 < arg_source_text.size()) { + after_str = arg_source_text.substr(sizeof_end_index + 1); + } + + auto index = before_str.size() - 1; + while (0 <= index) { + if ('*' == before_str[index]) { + asterisk_found = true; + } + if (!std::isspace(before_str[index])) { + break; + } + + index -= 1; + } + if (asterisk_found) { + before_str = before_str.substr(0, index); + } else { + size_t index2 = 0; + while (after_str.size() > index2) { + if ('*' == after_str[index2]) { + asterisk_found = true; + } + if (!std::isspace(after_str[index2])) { + break; + } + + index2 += 1; + } + if (asterisk_found) { + after_str = after_str.substr(index2 + 1); + } + } + } + } + if (true || asterisk_found) { + retval.m_num_bytes_arg_iter = arg_iter; + retval.m_seems_to_be_some_kind_of_malloc_or_realloc = true; + retval.m_num_bytes_arg_source_text = arg_source_text; + if (ends_with_realloc) { + retval.m_seems_to_be_some_kind_of_realloc = true; + } + } + } + } + } + } + return retval; +} + class MCSSSVarDecl2 : public MatchFinder::MatchCallback { public: @@ -2963,6 +3068,10 @@ public: virtual void run(const MatchFinder::MatchResult &MR) { const DeclaratorDecl* DD = MR.Nodes.getNodeAs("mcsssvardecl"); + const Expr* RHS = MR.Nodes.getNodeAs("mcsssvardecl2"); + const clang::CStyleCastExpr* CCE = MR.Nodes.getNodeAs("mcsssvardecl3"); + //const DeclStmt* DS = MR.Nodes.getNodeAs("mcsssvardecl4"); + if ((DD != nullptr)) { auto SR = nice_source_range(DD->getSourceRange(), Rewrite); @@ -3014,6 +3123,140 @@ public: } update_declaration(*DD, Rewrite, m_state1); + + if (nullptr != RHS) { + auto rhs_res2 = infer_array_type_info_from_stmt(*RHS, "", (*this).m_state1); + bool lhs_is_an_indirect_type = is_an_indirect_type(DD->getType()); + bool rhs_is_an_indirect_type = is_an_indirect_type(RHS->getType()); + assert(lhs_is_an_indirect_type == rhs_is_an_indirect_type); + + if (rhs_res2.ddecl_cptr && rhs_res2.update_declaration_flag) { + update_declaration(*(rhs_res2.ddecl_cptr), Rewrite, m_state1); + } + + if ((nullptr != CCE) && (rhs_res2.ddecl_conversion_state_ptr)) { + auto cce_QT = CCE->getType(); + auto rhs_QT = RHS->getType(); + if (cce_QT == rhs_QT) { + CIndirectionStateStack rhs_qtype_indirection_state_stack; + auto direct_rhs_qtype = populateQTypeIndirectionStack(rhs_qtype_indirection_state_stack, rhs_QT); + auto direct_rhs_qtype_str = direct_rhs_qtype.getAsString(); + auto casted_expr_ptr = CCE->IgnoreCasts(); + if (llvm::isa(casted_expr_ptr->IgnoreParenCasts())) { + auto CE = llvm::cast(casted_expr_ptr->IgnoreParenCasts()); + auto alloc_function_info1 = analyze_malloc_resemblance(*CE, Rewrite); + if (alloc_function_info1.m_seems_to_be_some_kind_of_malloc_or_realloc) { + /* This seems to be some kind of malloc/realloc function. These case should not be + * handled here. They are handled elsewhere. */ + return; + } + } + + if ((rhs_qtype_indirection_state_stack.size() + rhs_res2.indirection_level + == (*(rhs_res2.ddecl_conversion_state_ptr)).m_indirection_state_stack.size()) + && (1 <= (*rhs_res2.ddecl_conversion_state_ptr).m_indirection_state_stack.size()) + && (nullptr != casted_expr_ptr)) { + + std::string rhs_ddecl_current_direct_qtype_str = (*rhs_res2.ddecl_conversion_state_ptr).m_current_direct_qtype_str; + auto casted_expr_SR = nice_source_range(casted_expr_ptr->getSourceRange(), Rewrite); + auto CCESR = nice_source_range(CCE->getSourceRange(), Rewrite); + auto cast_operation_SR = clang::SourceRange(CCE->getLParenLoc(), CCE->getRParenLoc()); + + if (cast_operation_SR.isValid() + && (("void" == rhs_ddecl_current_direct_qtype_str) || ("const void" == rhs_ddecl_current_direct_qtype_str))) { + if (ConvertToSCPP) { + (*rhs_res2.ddecl_conversion_state_ptr).set_current_direct_qtype(direct_rhs_qtype); + + auto cast_operation_text = Rewrite.getRewrittenText(cast_operation_SR); + /* This is not the proper way to modify an expression. See the function + * CConditionalOperatorReconciliation2ReplacementAction::do_replacement() for an example of + * the proper way to do it. But for now this is good enough. */ + auto res2 = Rewrite.ReplaceText(cast_operation_SR, ""); + + static const std::string void_str = "void"; + auto void_pos = (*rhs_res2.ddecl_conversion_state_ptr).m_initializer_info_str.find(void_str); + if (std::string::npos != void_pos) { + (*rhs_res2.ddecl_conversion_state_ptr).m_initializer_info_str.replace(void_pos, void_str.length(), direct_rhs_qtype_str); + } + + update_declaration(*(rhs_res2.ddecl_cptr), Rewrite, m_state1); + } + } else { + if (ConvertToSCPP) { + if (false) { + (*rhs_res2.ddecl_conversion_state_ptr).set_current_direct_qtype(direct_rhs_qtype); + } + } + } + } else { + int q = 7; + } + } else { + int q = 7; + } + } + + int lhs_indirection_level_adjustment = 0; + auto rhs_res3 = leading_addressof_operator_info_from_stmt(*RHS); + if (rhs_res3.without_leading_addressof_operator_expr_cptr) { + assert(rhs_res3.leading_addressof_operator_detected && rhs_res3.addressof_unary_operator_cptr); + + RHS = rhs_res3.without_leading_addressof_operator_expr_cptr; + rhs_res2 = infer_array_type_info_from_stmt(*RHS, "", (*this).m_state1); + 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(rhs_res3.without_leading_addressof_operator_expr_cptr)); + array_subscript_expr_cptr = llvm::cast(rhs_res3.without_leading_addressof_operator_expr_cptr); + } + if (ConvertToSCPP && array_subscript_expr_cptr) { + std::shared_ptr cr_shptr = std::make_shared(Rewrite, MR, + CDDeclIndirection(*DD, 0), *(rhs_res3.addressof_unary_operator_cptr), *array_subscript_expr_cptr); + + if (ddcs_ref.has_been_determined_to_be_an_array()) { + (*cr_shptr).do_replacement(m_state1); + } else { + m_state1.m_array2_contingent_replacement_map.insert(cr_shptr); + } + } + } + + if (ConvertToSCPP && (rhs_res2.ddecl_conversion_state_ptr) && lhs_is_an_indirect_type) { + for (size_t i = 0; (rhs_res2.indirection_level + i < ddcs_ref.m_indirection_state_stack.size()) + && (rhs_res2.indirection_level + i < (*(rhs_res2.ddecl_conversion_state_ptr)).m_indirection_state_stack.size()); i += 1) { + { + /* Here we're establishing and "enforcing" the constraint that the rhs value must + * be of an (array) type that can be assigned to the lhs. */ + auto cr_shptr = std::make_shared(Rewrite, MR, CDDeclIndirection(*DD, 0 + i), CDDeclIndirection(*(rhs_res2.ddecl_cptr), rhs_res2.indirection_level + i)); + auto cr_shptr2 = std::make_shared(Rewrite, MR, CDDeclIndirection(*DD, 0 + i), CDDeclIndirection(*(rhs_res2.ddecl_cptr), rhs_res2.indirection_level + i)); + + if (ddcs_ref.has_been_determined_to_be_an_array(0 + i)) { + (*cr_shptr).do_replacement(m_state1); + if (ddcs_ref.has_been_determined_to_be_a_dynamic_array(0 + i)) { + (*cr_shptr2).do_replacement(m_state1); + } else { + m_state1.m_dynamic_array2_contingent_replacement_map.insert(cr_shptr2); + } + } else { + m_state1.m_array2_contingent_replacement_map.insert(cr_shptr); + m_state1.m_dynamic_array2_contingent_replacement_map.insert(cr_shptr2); + } + } + { + /* Here we're establishing the constraint in the opposite direction as well. */ + auto cr_shptr = std::make_shared(Rewrite, MR, CDDeclIndirection(*(rhs_res2.ddecl_cptr), rhs_res2.indirection_level + i), CDDeclIndirection(*DD, 0 + i)); + + if ((*(rhs_res2.ddecl_conversion_state_ptr)).has_been_determined_to_be_an_array(rhs_res2.indirection_level + i)) { + (*cr_shptr).do_replacement(m_state1); + } else { + m_state1.m_array2_contingent_replacement_map.insert(cr_shptr); + } + } + } + } + + } } } @@ -3119,102 +3362,6 @@ private: /**********************************************************************************************************************/ -struct CAllocFunctionInfo { - bool m_seems_to_be_some_kind_of_malloc_or_realloc = false; - bool m_seems_to_be_some_kind_of_realloc = false; - clang::CallExpr::const_arg_iterator m_num_bytes_arg_iter; - std::string m_num_bytes_arg_source_text; -}; -CAllocFunctionInfo analyze_malloc_resemblance(const clang::CallExpr& call_expr, Rewriter &Rewrite) { - CAllocFunctionInfo retval; - - auto CE = &call_expr; - auto function_decl = CE->getDirectCallee(); - auto num_args = CE->getNumArgs(); - if (function_decl && ((1 == num_args) || (2 == num_args))) { - std::string function_name = function_decl->getNameAsString(); - static const std::string alloc_str = "alloc"; - static const std::string realloc_str = "realloc"; - auto lc_function_name = tolowerstr(function_name); - bool ends_with_alloc = ((lc_function_name.size() >= alloc_str.size()) - && (0 == lc_function_name.compare(lc_function_name.size() - alloc_str.size(), alloc_str.size(), alloc_str))); - bool ends_with_realloc = (ends_with_alloc && (lc_function_name.size() >= realloc_str.size()) - && (0 == lc_function_name.compare(lc_function_name.size() - realloc_str.size(), realloc_str.size(), realloc_str))); - bool still_potentially_valid1 = (ends_with_alloc && (1 == num_args)) || (ends_with_realloc && (2 == num_args)); - if (still_potentially_valid1) { - auto arg_iter = CE->arg_begin(); - if (ends_with_realloc) { - arg_iter++; - } - bool argIsIntegerType = false; - if (*arg_iter) { - argIsIntegerType = (*arg_iter)->getType().split().asPair().first->isIntegerType(); - } - if (argIsIntegerType) { - 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); - - bool asterisk_found = false; - auto sizeof_start_index = arg_source_text.find("sizeof("); - if (std::string::npos != sizeof_start_index) { - auto sizeof_end_index = arg_source_text.find(")", sizeof_start_index); - if (std::string::npos != sizeof_end_index) { - assert(sizeof_end_index > sizeof_start_index); - std::string before_str = arg_source_text.substr(0, sizeof_start_index); - std::string after_str; - if (sizeof_end_index + 1 < arg_source_text.size()) { - after_str = arg_source_text.substr(sizeof_end_index + 1); - } - - auto index = before_str.size() - 1; - while (0 <= index) { - if ('*' == before_str[index]) { - asterisk_found = true; - } - if (!std::isspace(before_str[index])) { - break; - } - - index -= 1; - } - if (asterisk_found) { - before_str = before_str.substr(0, index); - } else { - size_t index2 = 0; - while (after_str.size() > index2) { - if ('*' == after_str[index2]) { - asterisk_found = true; - } - if (!std::isspace(after_str[index2])) { - break; - } - - index2 += 1; - } - if (asterisk_found) { - after_str = after_str.substr(index2 + 1); - } - } - } - } - if (true || asterisk_found) { - retval.m_num_bytes_arg_iter = arg_iter; - retval.m_seems_to_be_some_kind_of_malloc_or_realloc = true; - retval.m_num_bytes_arg_source_text = arg_source_text; - if (ends_with_realloc) { - retval.m_seems_to_be_some_kind_of_realloc = true; - } - } - } - } - } - } - return retval; -} - class MCSSSMalloc2 : public MatchFinder::MatchCallback { public: @@ -3594,8 +3741,8 @@ public: } Expr::NullPointerConstantKind kind = RHS->IgnoreParenCasts()->isNullPointerConstant(*ASTC, Expr::NullPointerConstantValueDependence()); - if (false && clang::Expr::NPCK_NotNull != kind) { - if (true) { + if (clang::Expr::NPCK_NotNull != kind) { + if (false) { { if (true) { if (true) { @@ -4896,6 +5043,10 @@ public: auto fdecl_source_range = nice_source_range(function_decl->getSourceRange(), Rewrite); auto fdecl_source_location_str = fdecl_source_range.getBegin().printToString(*MR.SourceManager); + if (filtered_out_by_location(MR, fdecl_source_range.getBegin())) { + return void(); + } + for (size_t arg_index = 0; (CE->getNumArgs() > arg_index) && (function_decl->getNumParams() > arg_index); arg_index += 1) { auto param_VD = function_decl->getParamDecl(arg_index); auto arg_EX = CE->getArg(arg_index); @@ -5859,7 +6010,14 @@ public: Matcher.addMatcher(castExpr(allOf(hasCastKind(CK_ArrayToPointerDecay), unless(hasParent(arraySubscriptExpr())))).bind("mcsssarraytopointerdecay"), &HandlerForSSSArrayToPointerDecay); - Matcher.addMatcher(clang::ast_matchers::declaratorDecl().bind("mcsssvardecl"), &HandlerForSSSVarDecl2); + //Matcher.addMatcher(clang::ast_matchers::declaratorDecl().bind("mcsssvardecl"), &HandlerForSSSVarDecl2); + Matcher.addMatcher(varDecl(anyOf( + hasInitializer(anyOf( + expr(cStyleCastExpr(hasDescendant(declRefExpr().bind("mcsssvardecl5"))).bind("mcsssvardecl3")).bind("mcsssvardecl2"), + expr(hasDescendant(declRefExpr().bind("mcsssvardecl5"))).bind("mcsssvardecl2") + )), + clang::ast_matchers::anything() + )).bind("mcsssvardecl"), &HandlerForSSSVarDecl2); Matcher.addMatcher(expr(allOf( hasParent(expr(anyOf( @@ -6211,15 +6369,16 @@ public: } if (!(fii_ref.m_legacyhelpers_include_directive_found)) { - assert(fii_ref.m_first_include_directive_loc_is_valid); - TheRewriter.InsertTextBefore(fii_ref.m_first_include_directive_loc, - "#include \"mselegacyhelpers.h\"\n"); - } else if (fii_ref.m_first_macro_directive_ptr_is_valid) { - TheRewriter.InsertTextAfterToken(fii_ref.m_first_macro_directive_ptr->getLocation(), - "#include \"mselegacyhelpers.h\"\n"); - } else if (fii_ref.m_beginning_of_file_loc_is_valid) { - TheRewriter.InsertTextBefore(fii_ref.m_beginning_of_file_loc, - "#include \"mselegacyhelpers.h\"\n"); + if (fii_ref.m_first_include_directive_loc_is_valid) { + TheRewriter.InsertTextBefore(fii_ref.m_first_include_directive_loc, + "\n#include \"mselegacyhelpers.h\"\n"); + } else if (fii_ref.m_first_macro_directive_ptr_is_valid) { + TheRewriter.InsertTextAfterToken(fii_ref.m_first_macro_directive_ptr->getLocation(), + "\n#include \"mselegacyhelpers.h\"\n"); + } else if (fii_ref.m_beginning_of_file_loc_is_valid) { + TheRewriter.InsertTextBefore(fii_ref.m_beginning_of_file_loc, + "\n#include \"mselegacyhelpers.h\"\n"); + } } } } else { assert(false); } -- cgit v1.2.3