10#include "clang/AST/ASTContext.h"
11#include "clang/ASTMatchers/ASTMatchFinder.h"
12#include "clang/Frontend/CompilerInstance.h"
13#include "clang/Lex/Lexer.h"
14#include "clang/Lex/PPCallbacks.h"
15#include "clang/Lex/Preprocessor.h"
38static Preprocessor *
PP;
48 if (
const auto *DestVAT =
50 return DestVAT->getSizeExpr();
52 if (
const auto *DestVD = Result.Nodes.getNodeAs<VarDecl>(
DestVarDeclName))
53 if (
const TypeLoc DestTL = DestVD->getTypeSourceInfo()->getTypeLoc())
54 if (
const auto DestCTL = DestTL.getAs<ConstantArrayTypeLoc>())
55 return DestCTL.getSizeExpr();
63 const MatchFinder::MatchResult &Result) {
67 E = E->IgnoreImpCasts();
69 if (
const auto *LengthDRE = dyn_cast<DeclRefExpr>(E))
70 if (
const auto *LengthVD = dyn_cast<VarDecl>(LengthDRE->getDecl()))
71 if (!isa<ParmVarDecl>(LengthVD))
72 if (
const Expr *LengthInit = LengthVD->getInit();
73 LengthInit && !LengthInit->isValueDependent()) {
74 Expr::EvalResult Length;
75 if (LengthInit->EvaluateAsInt(Length, *Result.Context))
76 return Length.Val.getInt().getZExtValue();
79 if (
const auto *LengthIL = dyn_cast<IntegerLiteral>(E))
80 return LengthIL->getValue().getZExtValue();
82 if (
const auto *StrDRE = dyn_cast<DeclRefExpr>(E))
83 if (
const auto *StrVD = dyn_cast<VarDecl>(StrDRE->getDecl()))
84 if (
const Expr *StrInit = StrVD->getInit())
85 if (
const auto *StrSL =
86 dyn_cast<StringLiteral>(StrInit->IgnoreImpCasts()))
87 return StrSL->getLength();
89 if (
const auto *SrcSL = dyn_cast<StringLiteral>(E))
90 return SrcSL->getLength();
99 return getLength(DestCapacityExpr, Result);
105static const CallExpr *
getStrlenExpr(
const MatchFinder::MatchResult &Result) {
106 if (
const auto *StrlenExpr =
108 if (
const Decl *D = StrlenExpr->getCalleeDecl())
109 if (
const FunctionDecl *FD = D->getAsFunction())
110 if (
const IdentifierInfo *II = FD->getIdentifier())
111 if (II->isStr(
"strlen") || II->isStr(
"wcslen"))
133 if (
const Expr *Arg = StrlenCE->getArg(0)->IgnoreImpCasts())
134 if (
int ArgLength =
getLength(Arg, Result))
142 const MatchFinder::MatchResult &Result) {
146 return Lexer::getSourceText(
147 CharSourceRange::getTokenRange(E->getSourceRange()),
148 *Result.SourceManager, Result.Context->getLangOpts(),
nullptr);
153 const MatchFinder::MatchResult &Result) {
154 return Lexer::getLocForEndOfToken(E->getEndLoc(), 0, *Result.SourceManager,
155 Result.Context->getLangOpts());
165static bool isInjectUL(
const MatchFinder::MatchResult &Result) {
177 StringRef DestCapacityExprStr =
179 StringRef LengthExprStr =
182 return !DestCapacityExprStr.empty() && !LengthExprStr.empty() &&
183 DestCapacityExprStr.contains(LengthExprStr);
188 if (
const auto *DestDRE = Result.Nodes.getNodeAs<DeclRefExpr>(
DestExprName))
189 if (
const auto *SrcDRE = Result.Nodes.getNodeAs<DeclRefExpr>(
SrcExprName))
190 return DestDRE->getDecl()->getCanonicalDecl() ==
191 SrcDRE->getDecl()->getCanonicalDecl();
198 const auto *DestExpr =
199 Result.Nodes.getNodeAs<CXXMemberCallExpr>(
DestExprName);
200 const auto *SrcExpr = Result.Nodes.getNodeAs<CXXMemberCallExpr>(
SrcExprName);
201 const auto *LengthExpr =
204 StringRef DestStr =
"", SrcStr =
"", LengthStr =
"";
206 if (
const CXXMethodDecl *DestMD = DestExpr->getMethodDecl())
207 DestStr = DestMD->getName();
210 if (
const CXXMethodDecl *SrcMD = SrcExpr->getMethodDecl())
211 SrcStr = SrcMD->getName();
214 if (
const CXXMethodDecl *LengthMD = LengthExpr->getMethodDecl())
215 LengthStr = LengthMD->getName();
217 return (LengthStr ==
"length" || LengthStr ==
"size") &&
218 (SrcStr ==
"data" || DestStr ==
"data");
232 if (GivenLength != 0 && SrcLength != 0 && GivenLength == SrcLength)
235 if (
const auto *LengthExpr = Result.Nodes.getNodeAs<Expr>(
LengthExprName))
236 if (isa<BinaryOperator>(LengthExpr->IgnoreParenImpCasts()))
241 if (
const auto *ArgDRE =
242 dyn_cast<DeclRefExpr>(StrlenCE->getArg(0)->IgnoreImpCasts()))
243 if (
const auto *SrcVD = Result.Nodes.getNodeAs<VarDecl>(
SrcVarDeclName))
244 return dyn_cast<VarDecl>(ArgDRE->getDecl()) == SrcVD;
264 int DestCapacity =
getLength(DestCapacityExpr, Result);
267 if (GivenLength != 0 && DestCapacity != 0)
272 StringRef DestCapacityExprStr =
exprToStr(DestCapacityExpr, Result);
273 if (DestCapacityExprStr.contains(
"+1") || DestCapacityExprStr.contains(
"+ 1"))
294 const MatchFinder::MatchResult &Result,
295 DiagnosticBuilder &Diag) {
296 LengthExpr = LengthExpr->IgnoreParenImpCasts();
299 bool IsMacroDefinition =
false;
300 StringRef LengthExprStr =
exprToStr(LengthExpr, Result);
301 Preprocessor::macro_iterator It =
PP->macro_begin();
302 while (It !=
PP->macro_end() && !IsMacroDefinition) {
303 if (It->first->getName() == LengthExprStr)
304 IsMacroDefinition =
true;
310 if (!IsMacroDefinition) {
311 if (
const auto *LengthIL = dyn_cast<IntegerLiteral>(LengthExpr)) {
313 LengthIL->getValue().getZExtValue() +
316 const auto NewLengthFix = FixItHint::CreateReplacement(
317 LengthIL->getSourceRange(),
318 (Twine(NewLength) + (
isInjectUL(Result) ?
"UL" :
"")).str());
319 Diag << NewLengthFix;
325 const auto *BO = dyn_cast<BinaryOperator>(LengthExpr);
326 if (BO && BO->getOpcode() == BO_Add &&
328 const Expr *LhsExpr = BO->getLHS()->IgnoreImpCasts();
329 const Expr *RhsExpr = BO->getRHS()->IgnoreImpCasts();
331 if (
const auto *LhsIL = dyn_cast<IntegerLiteral>(LhsExpr)) {
332 if (LhsIL->getValue().getZExtValue() == 1) {
333 Diag << FixItHint::CreateRemoval(
334 {LhsIL->getBeginLoc(),
335 RhsExpr->getBeginLoc().getLocWithOffset(-1)});
340 if (
const auto *RhsIL = dyn_cast<IntegerLiteral>(RhsExpr)) {
341 if (RhsIL->getValue().getZExtValue() == 1) {
342 Diag << FixItHint::CreateRemoval(
343 {LhsExpr->getEndLoc().getLocWithOffset(1), RhsIL->getEndLoc()});
350 bool NeedInnerParen = BO && BO->getOpcode() != BO_Add;
353 Diag << FixItHint::CreateInsertion(LengthExpr->getBeginLoc(),
"(");
355 SmallString<8> Injection;
362 Diag << FixItHint::CreateInsertion(
exprLocEnd(LengthExpr, Result), Injection);
366 const MatchFinder::MatchResult &Result,
367 DiagnosticBuilder &Diag) {
368 const auto *LengthExpr = Result.Nodes.getNodeAs<Expr>(
LengthExprName);
373 const MatchFinder::MatchResult &Result,
374 DiagnosticBuilder &Diag) {
375 const auto *FunctionExpr = Result.Nodes.getNodeAs<CallExpr>(
FunctionExprName);
382 DiagnosticBuilder &Diag) {
383 const auto *Dest = Result.Nodes.getNodeAs<Expr>(
DestExprName);
387 std::string TempTyStr = Dest->getType().getAsString();
388 StringRef TyStr = TempTyStr;
389 if (TyStr.starts_with(
"char") || TyStr.starts_with(
"wchar_t"))
392 Diag << FixItHint::CreateInsertion(Dest->getBeginLoc(),
"(char *)");
399 DiagnosticBuilder &Diag) {
408static void removeArg(
int ArgPos,
const MatchFinder::MatchResult &Result,
409 DiagnosticBuilder &Diag) {
414 const auto *FunctionExpr = Result.Nodes.getNodeAs<CallExpr>(
FunctionExprName);
415 const Expr *ArgToRemove = FunctionExpr->getArg(ArgPos);
416 const Expr *LHSArg = FunctionExpr->getArg(ArgPos - 1);
417 const auto RemoveArgFix = FixItHint::CreateRemoval(
419 exprLocEnd(ArgToRemove, Result).getLocWithOffset(-1)));
420 Diag << RemoveArgFix;
424 const MatchFinder::MatchResult &Result,
425 DiagnosticBuilder &Diag) {
426 const auto *FunctionExpr = Result.Nodes.getNodeAs<CallExpr>(
FunctionExprName);
428 FunctionExpr->getDirectCallee()->getIdentifier()->getLength();
429 SourceRange FuncNameRange(
430 FunctionExpr->getBeginLoc(),
431 FunctionExpr->getBeginLoc().getLocWithOffset(FuncNameLength - 1));
433 const auto FuncNameFix =
434 FixItHint::CreateReplacement(FuncNameRange, NewFuncName);
439 const MatchFinder::MatchResult &Result,
440 DiagnosticBuilder &Diag) {
441 SmallString<10> NewFuncName;
442 NewFuncName = (Name[0] !=
'w') ?
"str" :
"wcs";
443 NewFuncName += IsCopy ?
"cpy" :
"ncpy";
444 NewFuncName += IsSafe ?
"_s" :
"";
449 const MatchFinder::MatchResult &Result,
450 DiagnosticBuilder &Diag) {
451 const auto *FunctionExpr = Result.Nodes.getNodeAs<CallExpr>(
FunctionExprName);
452 SmallString<64> NewSecondArg;
455 NewSecondArg = Twine(IsOverflows ? DestLength + 1 : DestLength).str();
459 (IsOverflows ? (!
isInjectUL(Result) ?
" + 1" :
" + 1UL") :
""))
463 NewSecondArg +=
", ";
464 const auto InsertNewArgFix = FixItHint::CreateInsertion(
465 FunctionExpr->getArg(1)->getBeginLoc(), NewSecondArg);
466 Diag << InsertNewArgFix;
470 const MatchFinder::MatchResult &Result,
471 DiagnosticBuilder &Diag) {
472 const auto *FunctionExpr = Result.Nodes.getNodeAs<CallExpr>(
FunctionExprName);
473 int FuncLocStartColumn = Result.SourceManager->getPresumedColumnNumber(
474 FunctionExpr->getBeginLoc());
475 SourceRange SpaceRange(
476 FunctionExpr->getBeginLoc().getLocWithOffset(-FuncLocStartColumn + 1),
477 FunctionExpr->getBeginLoc());
478 StringRef SpaceBeforeStmtStr = Lexer::getSourceText(
479 CharSourceRange::getCharRange(SpaceRange), *Result.SourceManager,
480 Result.Context->getLangOpts(),
nullptr);
482 SmallString<128> NewAddNullTermExprStr;
483 NewAddNullTermExprStr =
484 (Twine(
'\n') + SpaceBeforeStmtStr +
487 "] = " + ((Name[0] !=
'w') ? R
"('\0';)" : R"(L'\0';)"))
490 const auto AddNullTerminatorExprFix = FixItHint::CreateInsertion(
491 exprLocEnd(FunctionExpr, Result).getLocWithOffset(1),
492 NewAddNullTermExprStr);
493 Diag << AddNullTerminatorExprFix;
503 WantToUseSafeFunctions(Options.get(
"WantToUseSafeFunctions", true)) {}
507 Options.store(Opts,
"WantToUseSafeFunctions", WantToUseSafeFunctions);
511 const SourceManager &SM, Preprocessor *Pp, Preprocessor *ModuleExpanderPP) {
516AST_MATCHER_P(Expr, hasDefinition, ast_matchers::internal::Matcher<Expr>,
518 const Expr *SimpleNode = &Node;
519 SimpleNode = SimpleNode->IgnoreParenImpCasts();
521 if (InnerMatcher.matches(*SimpleNode, Finder, Builder))
524 auto DREHasInit = ignoringImpCasts(
525 declRefExpr(to(varDecl(hasInitializer(ignoringImpCasts(InnerMatcher))))));
527 if (DREHasInit.matches(*SimpleNode, Finder, Builder))
530 const char *
const VarDeclName =
"variable-declaration";
531 auto DREHasDefinition = ignoringImpCasts(declRefExpr(
532 to(varDecl().bind(VarDeclName)),
533 hasAncestor(compoundStmt(hasDescendant(binaryOperator(
534 hasLHS(declRefExpr(to(varDecl(equalsBoundNode(VarDeclName))))),
535 hasRHS(ignoringImpCasts(InnerMatcher))))))));
537 if (DREHasDefinition.matches(*SimpleNode, Finder, Builder))
546 binaryOperator(hasOperatorName(
"+"),
547 hasEitherOperand(ignoringParenImpCasts(integerLiteral())));
550 binaryOperator(hasOperatorName(
"-"),
551 hasEitherOperand(ignoringParenImpCasts(integerLiteral())));
553 auto HasIncOp = anyOf(ignoringImpCasts(IncOp), hasDescendant(IncOp));
554 auto HasDecOp = anyOf(ignoringImpCasts(DecOp), hasDescendant(DecOp));
556 auto Container = ignoringImpCasts(cxxMemberCallExpr(hasDescendant(declRefExpr(
557 hasType(hasUnqualifiedDesugaredType(recordType(hasDeclaration(recordDecl(
558 hasAnyName(
"::std::vector",
"::std::list",
"::std::deque"))))))))));
560 auto StringTy = type(hasUnqualifiedDesugaredType(recordType(
561 hasDeclaration(cxxRecordDecl(hasName(
"::std::basic_string"))))));
564 anyOf(hasType(StringTy), hasType(qualType(pointsTo(StringTy))));
566 auto CharTyArray = hasType(qualType(hasCanonicalType(
569 auto CharTyPointer = hasType(
570 qualType(hasCanonicalType(pointerType(pointee(isAnyCharacter())))));
572 auto AnyOfCharTy = anyOf(CharTyArray, CharTyPointer);
580 callExpr(callee(functionDecl(hasAnyName(
"::strlen",
"::wcslen"))))
585 cxxMemberCallExpr(on(expr(AnyOfStringTy).bind(
"Foo")),
586 has(memberExpr(member(hasAnyName(
"size",
"length")))))
590 auto SizeOfCharExpr = unaryExprOrTypeTraitExpr(has(expr(AnyOfCharTy)));
593 ignoringImpCasts(anyOf(Strlen, SizeOrLength, hasDescendant(Strlen),
594 hasDescendant(SizeOrLength)));
598 ignoringImpCasts(declRefExpr(to(varDecl(hasInitializer(WrongLength)))));
600 auto AnyOfCallOrDREWithoutInc = anyOf(DREWithoutInc, WrongLength);
603 auto CallExprReturnWithoutInc = ignoringImpCasts(callExpr(callee(functionDecl(
604 hasBody(has(returnStmt(hasReturnValue(AnyOfCallOrDREWithoutInc))))))));
607 auto DREHasReturnWithoutInc = ignoringImpCasts(
608 declRefExpr(to(varDecl(hasInitializer(CallExprReturnWithoutInc)))));
610 auto AnyOfWrongLengthInit =
611 anyOf(WrongLength, AnyOfCallOrDREWithoutInc, CallExprReturnWithoutInc,
612 DREHasReturnWithoutInc);
620 auto SizeExpr = anyOf(SizeOfCharExpr, integerLiteral(equals(1)));
622 auto MallocLengthExpr = allOf(
624 hasAnyName(
"::alloca",
"::calloc",
"malloc",
"realloc"))),
628 auto DestMalloc = anyOf(callExpr(MallocLengthExpr),
629 hasDescendant(callExpr(MallocLengthExpr)));
632 auto DestCXXNewExpr = ignoringImpCasts(
635 auto AnyOfDestInit = anyOf(DestMalloc, DestCXXNewExpr);
638 auto DestArrayTyDecl = declRefExpr(
643 auto DestUnknownDecl =
648 auto AnyOfDestDecl = ignoringImpCasts(
649 anyOf(allOf(hasDefinition(anyOf(AnyOfDestInit, DestArrayTyDecl,
650 hasDescendant(DestArrayTyDecl))),
652 anyOf(DestUnknownDecl, hasDescendant(DestUnknownDecl))));
654 auto NullTerminatorExpr = binaryOperator(
655 hasLHS(anyOf(hasDescendant(declRefExpr(to(varDecl(
657 hasDescendant(declRefExpr(
659 hasRHS(ignoringImpCasts(
660 anyOf(characterLiteral(equals(0U)), integerLiteral(equals(0))))));
664 anyOf(hasAncestor(cxxMemberCallExpr().bind(
SrcExprName)),
668 ignoringImpCasts(anyOf(stringLiteral().bind(
SrcExprName),
670 SrcDecl, hasDescendant(SrcDecl)));
677 CallContext(StringRef Name, std::optional<unsigned> DestinationPos,
678 std::optional<unsigned> SourcePos,
unsigned LengthPos,
680 : Name(Name), DestinationPos(DestinationPos), SourcePos(SourcePos),
681 LengthPos(LengthPos), WithIncrease(WithIncrease) {};
684 std::optional<unsigned> DestinationPos;
685 std::optional<unsigned> SourcePos;
690 auto MatchDestination = [=](CallContext CC) {
691 return hasArgument(*CC.DestinationPos,
693 unless(hasAncestor(compoundStmt(
694 hasDescendant(NullTerminatorExpr)))),
698 auto MatchSource = [=](CallContext CC) {
699 return hasArgument(*CC.SourcePos, AnyOfSrcDecl);
702 auto MatchGivenLength = [=](CallContext CC) {
707 allOf(unless(hasDefinition(SizeOfCharExpr)),
708 allOf(CC.WithIncrease
709 ? ignoringImpCasts(hasDefinition(HasIncOp))
711 allOf(unless(hasDefinition(HasIncOp)),
712 hasDefinition(optionally(
713 binaryOperator().bind(
715 AnyOfWrongLengthInit))),
719 auto MatchCall = [=](CallContext CC) {
720 std::string CharHandlerFuncName =
"::" + CC.Name.str();
723 std::string WcharHandlerFuncName =
724 "::" + (CC.Name.starts_with(
"mem") ?
"w" + CC.Name.str()
725 :
"wcs" + CC.Name.substr(3).str());
727 return allOf(callee(functionDecl(
728 hasAnyName(CharHandlerFuncName, WcharHandlerFuncName))),
729 MatchGivenLength(CC));
732 auto Match = [=](CallContext CC) {
733 if (CC.DestinationPos && CC.SourcePos)
734 return allOf(MatchCall(CC), MatchDestination(CC), MatchSource(CC));
736 if (CC.DestinationPos && !CC.SourcePos)
737 return allOf(MatchCall(CC), MatchDestination(CC),
738 hasArgument(*CC.DestinationPos, anything()));
740 if (!CC.DestinationPos && CC.SourcePos)
741 return allOf(MatchCall(CC), MatchSource(CC),
742 hasArgument(*CC.SourcePos, anything()));
744 llvm_unreachable(
"Unhandled match");
748 auto Memcpy = Match({
"memcpy", 0, 1, 2,
false});
751 auto MemcpyS = Match({
"memcpy_s", 0, 2, 3,
false});
754 auto Memchr = Match({
"memchr", std::nullopt, 0, 2,
false});
757 auto Memmove = Match({
"memmove", 0, 1, 2,
false});
760 auto MemmoveS = Match({
"memmove_s", 0, 2, 3,
false});
763 auto StrncmpRHS = Match({
"strncmp", std::nullopt, 1, 2,
true});
764 auto StrncmpLHS = Match({
"strncmp", std::nullopt, 0, 2,
true});
767 auto Strxfrm = Match({
"strxfrm", 0, 1, 2,
false});
770 auto StrerrorS = Match({
"strerror_s", 0, std::nullopt, 1,
false});
772 auto AnyOfMatchers = anyOf(Memcpy, MemcpyS, Memmove, MemmoveS, StrncmpRHS,
773 StrncmpLHS, Strxfrm, StrerrorS);
780 unless(hasAncestor(castExpr(unless(implicitCastExpr())))))
784 castExpr(allOf(unless(implicitCastExpr()),
791 const MatchFinder::MatchResult &Result) {
792 const auto *FunctionExpr = Result.Nodes.getNodeAs<CallExpr>(
FunctionExprName);
793 if (FunctionExpr->getBeginLoc().isMacroID())
796 if (WantToUseSafeFunctions &&
PP->isMacroDefined(
"__STDC_LIB_EXT1__")) {
797 std::optional<bool> AreSafeFunctionsWanted;
799 Preprocessor::macro_iterator It =
PP->macro_begin();
800 while (It !=
PP->macro_end() && !AreSafeFunctionsWanted) {
801 if (It->first->getName() ==
"__STDC_WANT_LIB_EXT1__") {
802 const auto *MI =
PP->getMacroInfo(It->first);
805 const auto &T = MI->tokens().back();
806 if (T.isLiteral() && T.getLiteralData()) {
807 StringRef ValueStr = StringRef(T.getLiteralData(), T.getLength());
808 llvm::APInt IntValue;
809 ValueStr.getAsInteger(10, IntValue);
810 AreSafeFunctionsWanted = IntValue.getZExtValue();
818 if (AreSafeFunctionsWanted)
819 UseSafeFunctions = *AreSafeFunctionsWanted;
822 StringRef Name = FunctionExpr->getDirectCallee()->getName();
823 if (Name.starts_with(
"mem") || Name.starts_with(
"wmem"))
824 memoryHandlerFunctionFix(Name, Result);
825 else if (Name ==
"strerror_s")
826 strerror_sFix(Result);
827 else if (Name.ends_with(
"ncmp"))
828 ncmpFix(Name, Result);
829 else if (Name.ends_with(
"xfrm"))
830 xfrmFix(Name, Result);
833void NotNullTerminatedResultCheck::memoryHandlerFunctionFix(
834 StringRef Name,
const MatchFinder::MatchResult &Result) {
838 if (Name.ends_with(
"chr")) {
839 memchrFix(Name, Result);
843 if ((Name.contains(
"cpy") || Name.contains(
"move")) &&
849 "the result from calling '%0' is not null-terminated")
852 if (Name.ends_with(
"cpy")) {
853 memcpyFix(Name, Result, Diag);
854 }
else if (Name.ends_with(
"cpy_s")) {
855 memcpy_sFix(Name, Result, Diag);
856 }
else if (Name.ends_with(
"move")) {
857 memmoveFix(Name, Result, Diag);
858 }
else if (Name.ends_with(
"move_s")) {
864void NotNullTerminatedResultCheck::memcpyFix(
865 StringRef Name,
const MatchFinder::MatchResult &Result,
866 DiagnosticBuilder &Diag) {
873 bool IsSafe = UseSafeFunctions && IsOverflows &&
isKnownDest(Result) &&
876 bool IsDestLengthNotRequired =
877 IsSafe && getLangOpts().CPlusPlus &&
882 if (IsSafe && !IsDestLengthNotRequired)
888 if (!IsCopy && !IsSafe)
892void NotNullTerminatedResultCheck::memcpy_sFix(
893 StringRef Name,
const MatchFinder::MatchResult &Result,
894 DiagnosticBuilder &Diag) {
898 bool RemoveDestLength = getLangOpts().CPlusPlus &&
902 bool IsSafe = IsOverflows;
906 if (!IsSafe || (IsSafe && RemoveDestLength))
914 if (!IsCopy && !IsSafe)
918void NotNullTerminatedResultCheck::memchrFix(
919 StringRef Name,
const MatchFinder::MatchResult &Result) {
920 const auto *FunctionExpr = Result.Nodes.getNodeAs<CallExpr>(
FunctionExprName);
921 if (
const auto *GivenCL = dyn_cast<CharacterLiteral>(FunctionExpr->getArg(1)))
922 if (GivenCL->getValue() != 0)
925 auto Diag = diag(FunctionExpr->getArg(2)->IgnoreParenCasts()->getBeginLoc(),
926 "the length is too short to include the null terminator");
928 if (
const auto *CastExpr = Result.Nodes.getNodeAs<Expr>(
CastExprName)) {
929 const auto CastRemoveFix = FixItHint::CreateRemoval(
930 SourceRange(CastExpr->getBeginLoc(),
931 FunctionExpr->getBeginLoc().getLocWithOffset(-1)));
932 Diag << CastRemoveFix;
935 StringRef NewFuncName = (Name[0] !=
'w') ?
"strchr" :
"wcschr";
940void NotNullTerminatedResultCheck::memmoveFix(
941 StringRef Name,
const MatchFinder::MatchResult &Result,
942 DiagnosticBuilder &Diag)
const {
946 renameFunc((Name[0] !=
'w') ?
"memmove_s" :
"wmemmove_s", Result, Diag);
953void NotNullTerminatedResultCheck::strerror_sFix(
954 const MatchFinder::MatchResult &Result) {
957 "the result from calling 'strerror_s' is not null-terminated and "
958 "missing the last character of the error message");
964void NotNullTerminatedResultCheck::ncmpFix(
965 StringRef Name,
const MatchFinder::MatchResult &Result) {
966 const auto *FunctionExpr = Result.Nodes.getNodeAs<CallExpr>(
FunctionExprName);
967 const Expr *FirstArgExpr = FunctionExpr->getArg(0)->IgnoreImpCasts();
968 const Expr *SecondArgExpr = FunctionExpr->getArg(1)->IgnoreImpCasts();
969 bool IsLengthTooLong =
false;
972 const Expr *LengthExprArg = StrlenExpr->getArg(0);
973 StringRef FirstExprStr =
exprToStr(FirstArgExpr, Result).trim();
974 StringRef SecondExprStr =
exprToStr(SecondArgExpr, Result).trim();
975 StringRef LengthArgStr =
exprToStr(LengthExprArg, Result).trim();
977 LengthArgStr == FirstExprStr || LengthArgStr == SecondExprStr;
982 if (SrcLength != 0 && GivenLength != 0)
983 IsLengthTooLong = GivenLength > SrcLength;
989 auto Diag = diag(FunctionExpr->getArg(2)->IgnoreParenCasts()->getBeginLoc(),
990 "comparison length is too long and might lead to a "
996void NotNullTerminatedResultCheck::xfrmFix(
997 StringRef Name,
const MatchFinder::MatchResult &Result) {
1003 "the result from calling '%0' is not null-terminated")
Every ClangTidyCheck reports errors through a DiagnosticsEngine provided by this context.
void registerPPCallbacks(const SourceManager &SM, Preprocessor *PP, Preprocessor *ModuleExpanderPP) override
void registerMatchers(ast_matchers::MatchFinder *Finder) override
void storeOptions(ClangTidyOptions::OptionMap &Opts) override
NotNullTerminatedResultCheck(StringRef Name, ClangTidyContext *Context)
void check(const ast_matchers::MatchFinder::MatchResult &Result) override
constexpr llvm::StringLiteral CastExprName
static bool isStringDataAndLength(const MatchFinder::MatchResult &Result)
static bool isCorrectGivenLength(const MatchFinder::MatchResult &Result)
static const CallExpr * getStrlenExpr(const MatchFinder::MatchResult &Result)
static void renameFunc(StringRef NewFuncName, const MatchFinder::MatchResult &Result, DiagnosticBuilder &Diag)
static bool isKnownDest(const MatchFinder::MatchResult &Result)
static bool isDestAndSrcEquals(const MatchFinder::MatchResult &Result)
static bool isDestExprFix(const MatchFinder::MatchResult &Result, DiagnosticBuilder &Diag)
constexpr llvm::StringLiteral FunctionExprName
static SourceLocation exprLocEnd(const Expr *E, const MatchFinder::MatchResult &Result)
constexpr llvm::StringLiteral UnknownLengthName
static int getGivenLength(const MatchFinder::MatchResult &Result)
constexpr llvm::StringLiteral WrongLengthExprName
constexpr llvm::StringLiteral LengthExprName
static bool isDestBasedOnGivenLength(const MatchFinder::MatchResult &Result)
constexpr llvm::StringLiteral DestMallocExprName
constexpr llvm::StringLiteral DestArrayTyName
constexpr llvm::StringLiteral UnknownDestName
static const Expr * getDestCapacityExpr(const MatchFinder::MatchResult &Result)
static bool isGivenLengthEqualToSrcLength(const MatchFinder::MatchResult &Result)
constexpr llvm::StringLiteral SrcVarDeclName
static int getDestCapacity(const MatchFinder::MatchResult &Result)
static bool isDestCapacityOverflows(const MatchFinder::MatchResult &Result)
static bool isInjectUL(const MatchFinder::MatchResult &Result)
static bool isFixedGivenLengthAndUnknownSrc(const MatchFinder::MatchResult &Result)
static void lengthExprHandle(const Expr *LengthExpr, LengthHandleKind LengthHandle, const MatchFinder::MatchResult &Result, DiagnosticBuilder &Diag)
static void lengthArgHandle(LengthHandleKind LengthHandle, const MatchFinder::MatchResult &Result, DiagnosticBuilder &Diag)
static void lengthArgPosHandle(unsigned ArgPos, LengthHandleKind LengthHandle, const MatchFinder::MatchResult &Result, DiagnosticBuilder &Diag)
static bool isDestCapacityFix(const MatchFinder::MatchResult &Result, DiagnosticBuilder &Diag)
static StringRef exprToStr(const Expr *E, const MatchFinder::MatchResult &Result)
static void insertNullTerminatorExpr(StringRef Name, const MatchFinder::MatchResult &Result, DiagnosticBuilder &Diag)
constexpr llvm::StringLiteral DestVarDeclName
static void removeArg(int ArgPos, const MatchFinder::MatchResult &Result, DiagnosticBuilder &Diag)
static unsigned getLength(const Expr *E, const MatchFinder::MatchResult &Result)
static void insertDestCapacityArg(bool IsOverflows, StringRef Name, const MatchFinder::MatchResult &Result, DiagnosticBuilder &Diag)
static void renameMemcpy(StringRef Name, bool IsCopy, bool IsSafe, const MatchFinder::MatchResult &Result, DiagnosticBuilder &Diag)
constexpr llvm::StringLiteral SrcExprName
constexpr llvm::StringLiteral DestExprName
llvm::StringMap< ClangTidyValue > OptionMap