head 1.1; branch 1.1.1; access; symbols netbsd-10-2-RELEASE:1.1.1.3 netbsd-9-5-RELEASE:1.1.1.2 netbsd-11-0-RELEASE:1.1.1.3 netbsd-11-0-RC7:1.1.1.3 netbsd-11-0-RC6:1.1.1.3 netbsd-11-0-RC5:1.1.1.3 netbsd-11-0-RC4:1.1.1.3 netbsd-11-0-RC3:1.1.1.3 netbsd-11-0-RC2:1.1.1.3 netbsd-11-0-RC1:1.1.1.3 perseant-exfatfs-base-20250801:1.1.1.3 netbsd-11:1.1.1.3.0.10 netbsd-11-base:1.1.1.3 netbsd-10-1-RELEASE:1.1.1.3 perseant-exfatfs-base-20240630:1.1.1.3 perseant-exfatfs:1.1.1.3.0.8 perseant-exfatfs-base:1.1.1.3 netbsd-8-3-RELEASE:1.1.1.1 netbsd-9-4-RELEASE:1.1.1.2 netbsd-10-0-RELEASE:1.1.1.3 netbsd-10-0-RC6:1.1.1.3 netbsd-10-0-RC5:1.1.1.3 netbsd-10-0-RC4:1.1.1.3 netbsd-10-0-RC3:1.1.1.3 netbsd-10-0-RC2:1.1.1.3 netbsd-10-0-RC1:1.1.1.3 netbsd-10:1.1.1.3.0.6 netbsd-10-base:1.1.1.3 netbsd-9-3-RELEASE:1.1.1.2 cjep_sun2x:1.1.1.3.0.4 cjep_sun2x-base:1.1.1.3 cjep_staticlib_x-base1:1.1.1.3 netbsd-9-2-RELEASE:1.1.1.2 cjep_staticlib_x:1.1.1.3.0.2 cjep_staticlib_x-base:1.1.1.3 netbsd-9-1-RELEASE:1.1.1.2 phil-wifi-20200421:1.1.1.3 phil-wifi-20200411:1.1.1.3 phil-wifi-20200406:1.1.1.3 netbsd-8-2-RELEASE:1.1.1.1 netbsd-9-0-RELEASE:1.1.1.2 netbsd-9-0-RC2:1.1.1.2 netbsd-9-0-RC1:1.1.1.2 netbsd-9:1.1.1.2.0.2 netbsd-9-base:1.1.1.2 phil-wifi-20190609:1.1.1.2 netbsd-8-1-RELEASE:1.1.1.1 netbsd-8-1-RC1:1.1.1.1 pgoyette-compat-merge-20190127:1.1.1.1.14.1 pgoyette-compat-20190127:1.1.1.2 pgoyette-compat-20190118:1.1.1.2 pgoyette-compat-1226:1.1.1.2 pgoyette-compat-1126:1.1.1.2 pgoyette-compat-1020:1.1.1.2 pgoyette-compat-0930:1.1.1.2 pgoyette-compat-0906:1.1.1.2 pgoyette-compat-0728:1.1.1.2 clang-337282:1.1.1.2 netbsd-8-0-RELEASE:1.1.1.1 phil-wifi:1.1.1.1.0.16 phil-wifi-base:1.1.1.1 pgoyette-compat-0625:1.1.1.1 netbsd-8-0-RC2:1.1.1.1 pgoyette-compat-0521:1.1.1.1 pgoyette-compat-0502:1.1.1.1 pgoyette-compat-0422:1.1.1.1 netbsd-8-0-RC1:1.1.1.1 pgoyette-compat-0415:1.1.1.1 pgoyette-compat-0407:1.1.1.1 pgoyette-compat-0330:1.1.1.1 pgoyette-compat-0322:1.1.1.1 pgoyette-compat-0315:1.1.1.1 pgoyette-compat:1.1.1.1.0.14 pgoyette-compat-base:1.1.1.1 clang-319952:1.1.1.1 matt-nb8-mediatek:1.1.1.1.0.12 matt-nb8-mediatek-base:1.1.1.1 clang-309604:1.1.1.1 perseant-stdc-iso10646:1.1.1.1.0.10 perseant-stdc-iso10646-base:1.1.1.1 netbsd-8:1.1.1.1.0.8 netbsd-8-base:1.1.1.1 prg-localcount2-base3:1.1.1.1 prg-localcount2-base2:1.1.1.1 prg-localcount2-base1:1.1.1.1 prg-localcount2:1.1.1.1.0.6 prg-localcount2-base:1.1.1.1 pgoyette-localcount-20170426:1.1.1.1 bouyer-socketcan-base1:1.1.1.1 pgoyette-localcount:1.1.1.1.0.4 pgoyette-localcount-20170320:1.1.1.1 clang-294123:1.1.1.1 bouyer-socketcan:1.1.1.1.0.2 bouyer-socketcan-base:1.1.1.1 clang-291444:1.1.1.1 LLVM:1.1.1; locks; strict; comment @// @; 1.1 date 2017.01.11.10.35.38; author joerg; state Exp; branches 1.1.1.1; next ; commitid CNnUNfII1jgNmxBz; 1.1.1.1 date 2017.01.11.10.35.38; author joerg; state Exp; branches 1.1.1.1.4.1 1.1.1.1.14.1 1.1.1.1.16.1; next 1.1.1.2; commitid CNnUNfII1jgNmxBz; 1.1.1.2 date 2018.07.17.18.31.08; author joerg; state Exp; branches; next 1.1.1.3; commitid wDzL46ALjrCZgwKA; 1.1.1.3 date 2019.11.13.22.19.28; author joerg; state dead; branches; next ; commitid QD8YATxuNG34YJKB; 1.1.1.1.4.1 date 2017.01.11.10.35.38; author pgoyette; state dead; branches; next 1.1.1.1.4.2; commitid jjw7cAwgyKq7RfKz; 1.1.1.1.4.2 date 2017.03.20.06.52.42; author pgoyette; state Exp; branches; next ; commitid jjw7cAwgyKq7RfKz; 1.1.1.1.14.1 date 2018.07.28.04.33.23; author pgoyette; state Exp; branches; next ; commitid 1UP1xAIUxv1ZgRLA; 1.1.1.1.16.1 date 2019.06.10.21.45.28; author christos; state Exp; branches; next 1.1.1.1.16.2; commitid jtc8rnCzWiEEHGqB; 1.1.1.1.16.2 date 2020.04.13.07.46.38; author martin; state dead; branches; next ; commitid X01YhRUPVUDaec4C; desc @@ 1.1 log @Initial revision @ text @//==- GTestChecker.cpp - Model gtest API --*- C++ -*-==// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // // This checker models the behavior of un-inlined APIs from the gtest // unit-testing library to avoid false positives when using assertions from // that library. // //===----------------------------------------------------------------------===// #include "ClangSACheckers.h" #include "clang/AST/Expr.h" #include "clang/Basic/LangOptions.h" #include "clang/StaticAnalyzer/Core/Checker.h" #include "clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h" #include "clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h" #include "clang/StaticAnalyzer/Core/PathSensitive/ProgramState.h" #include "llvm/Support/raw_ostream.h" using namespace clang; using namespace ento; // Modeling of un-inlined AssertionResult constructors // // The gtest unit testing API provides macros for assertions that expand // into an if statement that calls a series of constructors and returns // when the "assertion" is false. // // For example, // // ASSERT_TRUE(a == b) // // expands into: // // switch (0) // case 0: // default: // if (const ::testing::AssertionResult gtest_ar_ = // ::testing::AssertionResult((a == b))) // ; // else // return ::testing::internal::AssertHelper( // ::testing::TestPartResult::kFatalFailure, // "", // , // ::testing::internal::GetBoolAssertionFailureMessage( // gtest_ar_, "a == b", "false", "true") // .c_str()) = ::testing::Message(); // // where AssertionResult is defined similarly to // // class AssertionResult { // public: // AssertionResult(const AssertionResult& other); // explicit AssertionResult(bool success) : success_(success) {} // operator bool() const { return success_; } // ... // private: // bool success_; // }; // // In order for the analyzer to correctly handle this assertion, it needs to // know that the boolean value of the expression "a == b" is stored the // 'success_' field of the original AssertionResult temporary and propagated // (via the copy constructor) into the 'success_' field of the object stored // in 'gtest_ar_'. That boolean value will then be returned from the bool // conversion method in the if statement. This guarantees that the assertion // holds when the return path is not taken. // // If the success value is not properly propagated, then the eager case split // on evaluating the expression can cause pernicious false positives // on the non-return path: // // ASSERT(ptr != NULL) // *ptr = 7; // False positive null pointer dereference here // // Unfortunately, the bool constructor cannot be inlined (because its // implementation is not present in the headers) and the copy constructor is // not inlined (because it is constructed into a temporary and the analyzer // does not inline these since it does not yet reliably call temporary // destructors). // // This checker compensates for the missing inlining by propagating the // _success value across the bool and copy constructors so the assertion behaves // as expected. namespace { class GTestChecker : public Checker { mutable IdentifierInfo *AssertionResultII; mutable IdentifierInfo *SuccessII; public: GTestChecker(); void checkPostCall(const CallEvent &Call, CheckerContext &C) const; private: void modelAssertionResultBoolConstructor(const CXXConstructorCall *Call, bool IsRef, CheckerContext &C) const; void modelAssertionResultCopyConstructor(const CXXConstructorCall *Call, CheckerContext &C) const; void initIdentifierInfo(ASTContext &Ctx) const; SVal getAssertionResultSuccessFieldValue(const CXXRecordDecl *AssertionResultDecl, SVal Instance, ProgramStateRef State) const; static ProgramStateRef assumeValuesEqual(SVal Val1, SVal Val2, ProgramStateRef State, CheckerContext &C); }; } // End anonymous namespace. GTestChecker::GTestChecker() : AssertionResultII(nullptr), SuccessII(nullptr) {} /// Model a call to an un-inlined AssertionResult(bool) or /// AssertionResult(bool &, ...). /// To do so, constrain the value of the newly-constructed instance's 'success_' /// field to be equal to the passed-in boolean value. /// /// \param IsRef Whether the boolean parameter is a reference or not. void GTestChecker::modelAssertionResultBoolConstructor( const CXXConstructorCall *Call, bool IsRef, CheckerContext &C) const { assert(Call->getNumArgs() >= 1 && Call->getNumArgs() <= 2); ProgramStateRef State = C.getState(); SVal BooleanArgVal = Call->getArgSVal(0); if (IsRef) { // The argument is a reference, so load from it to get the boolean value. if (!BooleanArgVal.getAs()) return; BooleanArgVal = C.getState()->getSVal(BooleanArgVal.castAs()); } SVal ThisVal = Call->getCXXThisVal(); SVal ThisSuccess = getAssertionResultSuccessFieldValue( Call->getDecl()->getParent(), ThisVal, State); State = assumeValuesEqual(ThisSuccess, BooleanArgVal, State, C); C.addTransition(State); } /// Model a call to an un-inlined AssertionResult copy constructor: /// /// AssertionResult(const &AssertionResult other) /// /// To do so, constrain the value of the newly-constructed instance's /// 'success_' field to be equal to the value of the pass-in instance's /// 'success_' field. void GTestChecker::modelAssertionResultCopyConstructor( const CXXConstructorCall *Call, CheckerContext &C) const { assert(Call->getNumArgs() == 1); // The first parameter of the the copy constructor must be the other // instance to initialize this instances fields from. SVal OtherVal = Call->getArgSVal(0); SVal ThisVal = Call->getCXXThisVal(); const CXXRecordDecl *AssertResultClassDecl = Call->getDecl()->getParent(); ProgramStateRef State = C.getState(); SVal ThisSuccess = getAssertionResultSuccessFieldValue(AssertResultClassDecl, ThisVal, State); SVal OtherSuccess = getAssertionResultSuccessFieldValue(AssertResultClassDecl, OtherVal, State); State = assumeValuesEqual(ThisSuccess, OtherSuccess, State, C); C.addTransition(State); } /// Model calls to AssertionResult constructors that are not inlined. void GTestChecker::checkPostCall(const CallEvent &Call, CheckerContext &C) const { /// If the constructor was inlined, there is no need model it. if (C.wasInlined) return; initIdentifierInfo(C.getASTContext()); auto *CtorCall = dyn_cast(&Call); if (!CtorCall) return; const CXXConstructorDecl *CtorDecl = CtorCall->getDecl(); const CXXRecordDecl *CtorParent = CtorDecl->getParent(); if (CtorParent->getIdentifier() != AssertionResultII) return; unsigned ParamCount = CtorDecl->getNumParams(); // Call the appropriate modeling method based the parameters and their // types. // We have AssertionResult(const &AssertionResult) if (CtorDecl->isCopyConstructor() && ParamCount == 1) { modelAssertionResultCopyConstructor(CtorCall, C); return; } // There are two possible boolean constructors, depending on which // version of gtest is being used: // // v1.7 and earlier: // AssertionResult(bool success) // // v1.8 and greater: // template // AssertionResult(const T& success, // typename internal::EnableIf< // !internal::ImplicitlyConvertible::value>::type*) // CanQualType BoolTy = C.getASTContext().BoolTy; if (ParamCount == 1 && CtorDecl->getParamDecl(0)->getType() == BoolTy) { // We have AssertionResult(bool) modelAssertionResultBoolConstructor(CtorCall, /*IsRef=*/false, C); return; } if (ParamCount == 2){ auto *RefTy = CtorDecl->getParamDecl(0)->getType()->getAs(); if (RefTy && RefTy->getPointeeType()->getCanonicalTypeUnqualified() == BoolTy) { // We have AssertionResult(bool &, ...) modelAssertionResultBoolConstructor(CtorCall, /*IsRef=*/true, C); return; } } } void GTestChecker::initIdentifierInfo(ASTContext &Ctx) const { if (AssertionResultII) return; AssertionResultII = &Ctx.Idents.get("AssertionResult"); SuccessII = &Ctx.Idents.get("success_"); } /// Returns the value stored in the 'success_' field of the passed-in /// AssertionResult instance. SVal GTestChecker::getAssertionResultSuccessFieldValue( const CXXRecordDecl *AssertionResultDecl, SVal Instance, ProgramStateRef State) const { DeclContext::lookup_result Result = AssertionResultDecl->lookup(SuccessII); if (Result.empty()) return UnknownVal(); auto *SuccessField = dyn_cast(Result.front()); if (!SuccessField) return UnknownVal(); Optional FieldLoc = State->getLValue(SuccessField, Instance).getAs(); if (!FieldLoc.hasValue()) return UnknownVal(); return State->getSVal(*FieldLoc); } /// Constrain the passed-in state to assume two values are equal. ProgramStateRef GTestChecker::assumeValuesEqual(SVal Val1, SVal Val2, ProgramStateRef State, CheckerContext &C) { if (!Val1.getAs() || !Val2.getAs()) return State; auto ValuesEqual = C.getSValBuilder().evalEQ(State, Val1.castAs(), Val2.castAs()); if (!ValuesEqual.getAs()) return State; State = C.getConstraintManager().assume( State, ValuesEqual.castAs(), true); return State; } void ento::registerGTestChecker(CheckerManager &Mgr) { const LangOptions &LangOpts = Mgr.getLangOpts(); // gtest is a C++ API so there is no sense running the checker // if not compiling for C++. if (!LangOpts.CPlusPlus) return; Mgr.registerChecker(); } @ 1.1.1.1 log @Import Clang pre-4.0.0 r291444. @ text @@ 1.1.1.1.16.1 log @Sync with HEAD @ text @d164 1 a164 1 // The first parameter of the copy constructor must be the other @ 1.1.1.1.16.2 log @Mostly merge changes from HEAD upto 20200411 @ text @@ 1.1.1.1.14.1 log @Sync with HEAD @ text @d164 1 a164 1 // The first parameter of the copy constructor must be the other @ 1.1.1.2 log @Import clang r337282 from trunk @ text @d164 1 a164 1 // The first parameter of the copy constructor must be the other @ 1.1.1.3 log @Mark old LLVM instance as dead. @ text @@ 1.1.1.1.4.1 log @file GTestChecker.cpp was added on branch pgoyette-localcount on 2017-03-20 06:52:42 +0000 @ text @d1 299 @ 1.1.1.1.4.2 log @Sync with HEAD @ text @a0 299 //==- GTestChecker.cpp - Model gtest API --*- C++ -*-==// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // // This checker models the behavior of un-inlined APIs from the gtest // unit-testing library to avoid false positives when using assertions from // that library. // //===----------------------------------------------------------------------===// #include "ClangSACheckers.h" #include "clang/AST/Expr.h" #include "clang/Basic/LangOptions.h" #include "clang/StaticAnalyzer/Core/Checker.h" #include "clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h" #include "clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h" #include "clang/StaticAnalyzer/Core/PathSensitive/ProgramState.h" #include "llvm/Support/raw_ostream.h" using namespace clang; using namespace ento; // Modeling of un-inlined AssertionResult constructors // // The gtest unit testing API provides macros for assertions that expand // into an if statement that calls a series of constructors and returns // when the "assertion" is false. // // For example, // // ASSERT_TRUE(a == b) // // expands into: // // switch (0) // case 0: // default: // if (const ::testing::AssertionResult gtest_ar_ = // ::testing::AssertionResult((a == b))) // ; // else // return ::testing::internal::AssertHelper( // ::testing::TestPartResult::kFatalFailure, // "", // , // ::testing::internal::GetBoolAssertionFailureMessage( // gtest_ar_, "a == b", "false", "true") // .c_str()) = ::testing::Message(); // // where AssertionResult is defined similarly to // // class AssertionResult { // public: // AssertionResult(const AssertionResult& other); // explicit AssertionResult(bool success) : success_(success) {} // operator bool() const { return success_; } // ... // private: // bool success_; // }; // // In order for the analyzer to correctly handle this assertion, it needs to // know that the boolean value of the expression "a == b" is stored the // 'success_' field of the original AssertionResult temporary and propagated // (via the copy constructor) into the 'success_' field of the object stored // in 'gtest_ar_'. That boolean value will then be returned from the bool // conversion method in the if statement. This guarantees that the assertion // holds when the return path is not taken. // // If the success value is not properly propagated, then the eager case split // on evaluating the expression can cause pernicious false positives // on the non-return path: // // ASSERT(ptr != NULL) // *ptr = 7; // False positive null pointer dereference here // // Unfortunately, the bool constructor cannot be inlined (because its // implementation is not present in the headers) and the copy constructor is // not inlined (because it is constructed into a temporary and the analyzer // does not inline these since it does not yet reliably call temporary // destructors). // // This checker compensates for the missing inlining by propagating the // _success value across the bool and copy constructors so the assertion behaves // as expected. namespace { class GTestChecker : public Checker { mutable IdentifierInfo *AssertionResultII; mutable IdentifierInfo *SuccessII; public: GTestChecker(); void checkPostCall(const CallEvent &Call, CheckerContext &C) const; private: void modelAssertionResultBoolConstructor(const CXXConstructorCall *Call, bool IsRef, CheckerContext &C) const; void modelAssertionResultCopyConstructor(const CXXConstructorCall *Call, CheckerContext &C) const; void initIdentifierInfo(ASTContext &Ctx) const; SVal getAssertionResultSuccessFieldValue(const CXXRecordDecl *AssertionResultDecl, SVal Instance, ProgramStateRef State) const; static ProgramStateRef assumeValuesEqual(SVal Val1, SVal Val2, ProgramStateRef State, CheckerContext &C); }; } // End anonymous namespace. GTestChecker::GTestChecker() : AssertionResultII(nullptr), SuccessII(nullptr) {} /// Model a call to an un-inlined AssertionResult(bool) or /// AssertionResult(bool &, ...). /// To do so, constrain the value of the newly-constructed instance's 'success_' /// field to be equal to the passed-in boolean value. /// /// \param IsRef Whether the boolean parameter is a reference or not. void GTestChecker::modelAssertionResultBoolConstructor( const CXXConstructorCall *Call, bool IsRef, CheckerContext &C) const { assert(Call->getNumArgs() >= 1 && Call->getNumArgs() <= 2); ProgramStateRef State = C.getState(); SVal BooleanArgVal = Call->getArgSVal(0); if (IsRef) { // The argument is a reference, so load from it to get the boolean value. if (!BooleanArgVal.getAs()) return; BooleanArgVal = C.getState()->getSVal(BooleanArgVal.castAs()); } SVal ThisVal = Call->getCXXThisVal(); SVal ThisSuccess = getAssertionResultSuccessFieldValue( Call->getDecl()->getParent(), ThisVal, State); State = assumeValuesEqual(ThisSuccess, BooleanArgVal, State, C); C.addTransition(State); } /// Model a call to an un-inlined AssertionResult copy constructor: /// /// AssertionResult(const &AssertionResult other) /// /// To do so, constrain the value of the newly-constructed instance's /// 'success_' field to be equal to the value of the pass-in instance's /// 'success_' field. void GTestChecker::modelAssertionResultCopyConstructor( const CXXConstructorCall *Call, CheckerContext &C) const { assert(Call->getNumArgs() == 1); // The first parameter of the the copy constructor must be the other // instance to initialize this instances fields from. SVal OtherVal = Call->getArgSVal(0); SVal ThisVal = Call->getCXXThisVal(); const CXXRecordDecl *AssertResultClassDecl = Call->getDecl()->getParent(); ProgramStateRef State = C.getState(); SVal ThisSuccess = getAssertionResultSuccessFieldValue(AssertResultClassDecl, ThisVal, State); SVal OtherSuccess = getAssertionResultSuccessFieldValue(AssertResultClassDecl, OtherVal, State); State = assumeValuesEqual(ThisSuccess, OtherSuccess, State, C); C.addTransition(State); } /// Model calls to AssertionResult constructors that are not inlined. void GTestChecker::checkPostCall(const CallEvent &Call, CheckerContext &C) const { /// If the constructor was inlined, there is no need model it. if (C.wasInlined) return; initIdentifierInfo(C.getASTContext()); auto *CtorCall = dyn_cast(&Call); if (!CtorCall) return; const CXXConstructorDecl *CtorDecl = CtorCall->getDecl(); const CXXRecordDecl *CtorParent = CtorDecl->getParent(); if (CtorParent->getIdentifier() != AssertionResultII) return; unsigned ParamCount = CtorDecl->getNumParams(); // Call the appropriate modeling method based the parameters and their // types. // We have AssertionResult(const &AssertionResult) if (CtorDecl->isCopyConstructor() && ParamCount == 1) { modelAssertionResultCopyConstructor(CtorCall, C); return; } // There are two possible boolean constructors, depending on which // version of gtest is being used: // // v1.7 and earlier: // AssertionResult(bool success) // // v1.8 and greater: // template // AssertionResult(const T& success, // typename internal::EnableIf< // !internal::ImplicitlyConvertible::value>::type*) // CanQualType BoolTy = C.getASTContext().BoolTy; if (ParamCount == 1 && CtorDecl->getParamDecl(0)->getType() == BoolTy) { // We have AssertionResult(bool) modelAssertionResultBoolConstructor(CtorCall, /*IsRef=*/false, C); return; } if (ParamCount == 2){ auto *RefTy = CtorDecl->getParamDecl(0)->getType()->getAs(); if (RefTy && RefTy->getPointeeType()->getCanonicalTypeUnqualified() == BoolTy) { // We have AssertionResult(bool &, ...) modelAssertionResultBoolConstructor(CtorCall, /*IsRef=*/true, C); return; } } } void GTestChecker::initIdentifierInfo(ASTContext &Ctx) const { if (AssertionResultII) return; AssertionResultII = &Ctx.Idents.get("AssertionResult"); SuccessII = &Ctx.Idents.get("success_"); } /// Returns the value stored in the 'success_' field of the passed-in /// AssertionResult instance. SVal GTestChecker::getAssertionResultSuccessFieldValue( const CXXRecordDecl *AssertionResultDecl, SVal Instance, ProgramStateRef State) const { DeclContext::lookup_result Result = AssertionResultDecl->lookup(SuccessII); if (Result.empty()) return UnknownVal(); auto *SuccessField = dyn_cast(Result.front()); if (!SuccessField) return UnknownVal(); Optional FieldLoc = State->getLValue(SuccessField, Instance).getAs(); if (!FieldLoc.hasValue()) return UnknownVal(); return State->getSVal(*FieldLoc); } /// Constrain the passed-in state to assume two values are equal. ProgramStateRef GTestChecker::assumeValuesEqual(SVal Val1, SVal Val2, ProgramStateRef State, CheckerContext &C) { if (!Val1.getAs() || !Val2.getAs()) return State; auto ValuesEqual = C.getSValBuilder().evalEQ(State, Val1.castAs(), Val2.castAs()); if (!ValuesEqual.getAs()) return State; State = C.getConstraintManager().assume( State, ValuesEqual.castAs(), true); return State; } void ento::registerGTestChecker(CheckerManager &Mgr) { const LangOptions &LangOpts = Mgr.getLangOpts(); // gtest is a C++ API so there is no sense running the checker // if not compiling for C++. if (!LangOpts.CPlusPlus) return; Mgr.registerChecker(); } @