[clang] f9e8e92 - Revert "[clang][analyzer] Add modeling of 'errno'."
Aaron Ballman via cfe-commits
cfe-commits at lists.llvm.org
Fri Feb 25 04:21:11 PST 2022
Author: Aaron Ballman
Date: 2022-02-25T07:21:01-05:00
New Revision: f9e8e92cf586d9cf077139a338f062a91b8ce2d2
URL: https://github.com/llvm/llvm-project/commit/f9e8e92cf586d9cf077139a338f062a91b8ce2d2
DIFF: https://github.com/llvm/llvm-project/commit/f9e8e92cf586d9cf077139a338f062a91b8ce2d2.diff
LOG: Revert "[clang][analyzer] Add modeling of 'errno'."
This reverts commit 29b512ba322cb6dd2c45d5e07645e20db47fad0d.
This broke several build bots:
https://lab.llvm.org/buildbot/#/builders/86/builds/30183
https://lab.llvm.org/buildbot/#/builders/216/builds/488
Added:
Modified:
clang/include/clang/StaticAnalyzer/Checkers/Checkers.td
clang/include/clang/StaticAnalyzer/Core/PathSensitive/MemRegion.h
clang/lib/StaticAnalyzer/Checkers/CMakeLists.txt
clang/lib/StaticAnalyzer/Core/MemRegion.cpp
clang/test/Analysis/Inputs/system-header-simulator.h
clang/test/Analysis/analyzer-enabled-checkers.c
clang/test/Analysis/global-region-invalidation.c
clang/test/Analysis/std-c-library-functions-arg-enabled-checkers.c
Removed:
clang/lib/StaticAnalyzer/Checkers/Errno.h
clang/lib/StaticAnalyzer/Checkers/ErrnoModeling.cpp
clang/lib/StaticAnalyzer/Checkers/ErrnoTesterChecker.cpp
clang/test/Analysis/Inputs/errno_func.h
clang/test/Analysis/Inputs/errno_var.h
clang/test/Analysis/errno.c
################################################################################
diff --git a/clang/include/clang/StaticAnalyzer/Checkers/Checkers.td b/clang/include/clang/StaticAnalyzer/Checkers/Checkers.td
index 6b72d64950106..fae4240e9d701 100644
--- a/clang/include/clang/StaticAnalyzer/Checkers/Checkers.td
+++ b/clang/include/clang/StaticAnalyzer/Checkers/Checkers.td
@@ -348,10 +348,6 @@ def NullableReturnedFromNonnullChecker : Checker<"NullableReturnedFromNonnull">,
let ParentPackage = APIModeling in {
-def ErrnoModeling : Checker<"Errno">,
- HelpText<"Make the special value 'errno' available to other checkers.">,
- Documentation<NotDocumented>;
-
def StdCLibraryFunctionsChecker : Checker<"StdCLibraryFunctions">,
HelpText<"Improve modeling of the C standard library functions">,
// Uninitialized value check is a mandatory dependency. This Checker asserts
@@ -1560,11 +1556,6 @@ def StreamTesterChecker : Checker<"StreamTester">,
"purposes.">,
Documentation<NotDocumented>;
-def ErrnoTesterChecker : Checker<"ErrnoTest">,
- HelpText<"Check modeling aspects of 'errno'.">,
- Dependencies<[ErrnoModeling]>,
- Documentation<NotDocumented>;
-
def ExprInspectionChecker : Checker<"ExprInspection">,
HelpText<"Check the analyzer's understanding of expressions">,
Documentation<NotDocumented>;
diff --git a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/MemRegion.h b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/MemRegion.h
index 0db6d92c63131..9f85347db5df7 100644
--- a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/MemRegion.h
+++ b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/MemRegion.h
@@ -764,8 +764,7 @@ class SymbolicRegion : public SubRegion {
assert(s->getType()->isAnyPointerType() ||
s->getType()->isReferenceType() ||
s->getType()->isBlockPointerType());
- assert(isa<UnknownSpaceRegion>(sreg) || isa<HeapSpaceRegion>(sreg) ||
- isa<GlobalSystemSpaceRegion>(sreg));
+ assert(isa<UnknownSpaceRegion>(sreg) || isa<HeapSpaceRegion>(sreg));
}
public:
@@ -1376,9 +1375,7 @@ class MemRegionManager {
const LocationContext *LC);
/// Retrieve or create a "symbolic" memory region.
- /// If no memory space is specified, `UnknownSpaceRegion` will be used.
- const SymbolicRegion *
- getSymbolicRegion(SymbolRef Sym, const MemSpaceRegion *MemSpace = nullptr);
+ const SymbolicRegion* getSymbolicRegion(SymbolRef Sym);
/// Return a unique symbolic region belonging to heap memory space.
const SymbolicRegion *getSymbolicHeapRegion(SymbolRef sym);
diff --git a/clang/lib/StaticAnalyzer/Checkers/CMakeLists.txt b/clang/lib/StaticAnalyzer/Checkers/CMakeLists.txt
index 15043c1c632e4..44fa2a06c3994 100644
--- a/clang/lib/StaticAnalyzer/Checkers/CMakeLists.txt
+++ b/clang/lib/StaticAnalyzer/Checkers/CMakeLists.txt
@@ -40,8 +40,6 @@ add_clang_library(clangStaticAnalyzerCheckers
DynamicTypePropagation.cpp
DynamicTypeChecker.cpp
EnumCastOutOfRangeChecker.cpp
- ErrnoModeling.cpp
- ErrnoTesterChecker.cpp
ExprInspectionChecker.cpp
FixedAddressChecker.cpp
FuchsiaHandleChecker.cpp
diff --git a/clang/lib/StaticAnalyzer/Checkers/Errno.h b/clang/lib/StaticAnalyzer/Checkers/Errno.h
deleted file mode 100644
index e564809d6bda9..0000000000000
--- a/clang/lib/StaticAnalyzer/Checkers/Errno.h
+++ /dev/null
@@ -1,39 +0,0 @@
-//=== Errno.h - Tracking value of 'errno'. -------------------------*- C++ -*-//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-//
-// Defines inter-checker API for using the system value 'errno'.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_CLANG_LIB_STATICANALYZER_CHECKERS_ERRNO_H
-#define LLVM_CLANG_LIB_STATICANALYZER_CHECKERS_ERRNO_H
-
-#include "clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h"
-#include "clang/StaticAnalyzer/Core/PathSensitive/ProgramState.h"
-#include "clang/StaticAnalyzer/Core/PathSensitive/SVals.h"
-
-namespace clang {
-namespace ento {
-namespace errno_modeling {
-
-/// Returns the value of 'errno', if 'errno' was found in the AST.
-llvm::Optional<SVal> getErrnoValue(ProgramStateRef State);
-
-/// Set value of 'errno' to any SVal, if possible.
-ProgramStateRef setErrnoValue(ProgramStateRef State,
- const LocationContext *LCtx, SVal Value);
-
-/// Set value of 'errno' to a concrete (signed) integer, if possible.
-ProgramStateRef setErrnoValue(ProgramStateRef State, CheckerContext &C,
- uint64_t Value);
-
-} // namespace errno_modeling
-} // namespace ento
-} // namespace clang
-
-#endif // LLVM_CLANG_LIB_STATICANALYZER_CHECKERS_ERRNO_H
diff --git a/clang/lib/StaticAnalyzer/Checkers/ErrnoModeling.cpp b/clang/lib/StaticAnalyzer/Checkers/ErrnoModeling.cpp
deleted file mode 100644
index f61d52e6e9d6e..0000000000000
--- a/clang/lib/StaticAnalyzer/Checkers/ErrnoModeling.cpp
+++ /dev/null
@@ -1,253 +0,0 @@
-//=== ErrnoModeling.cpp -----------------------------------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-//
-// This defines a checker `ErrnoModeling`, which is used to make the system
-// value 'errno' available to other checkers.
-// The 'errno' value is stored at a special memory region that is accessible
-// through the `errno_modeling` namespace. The memory region is either the
-// region of `errno` itself if it is a variable, otherwise an artifically
-// created region (in the system memory space). If `errno` is defined by using
-// a function which returns the address of it (this is always the case if it is
-// not a variable) this function is recognized and evaluated. In this way
-// `errno` becomes visible to the analysis and checkers can change its value.
-//
-//===----------------------------------------------------------------------===//
-
-#include "Errno.h"
-#include "clang/AST/ParentMapContext.h"
-#include "clang/StaticAnalyzer/Checkers/BuiltinCheckerRegistration.h"
-#include "clang/StaticAnalyzer/Core/Checker.h"
-#include "clang/StaticAnalyzer/Core/CheckerManager.h"
-#include "clang/StaticAnalyzer/Core/PathSensitive/CallDescription.h"
-#include "clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h"
-#include "clang/StaticAnalyzer/Core/PathSensitive/ProgramState.h"
-#include "clang/StaticAnalyzer/Core/PathSensitive/SVals.h"
-#include "llvm/ADT/STLExtras.h"
-
-using namespace clang;
-using namespace ento;
-
-namespace {
-
-// Name of the "errno" variable.
-// FIXME: Is there a system where it is not called "errno" but is a variable?
-const char *ErrnoVarName = "errno";
-// Names of functions that return a location of the "errno" value.
-// FIXME: Are there other similar function names?
-const char *ErrnoLocationFuncNames[] = {"__errno_location", "___errno",
- "__errno", "_errno", "__error"};
-
-class ErrnoModeling
- : public Checker<check::ASTDecl<TranslationUnitDecl>, check::BeginFunction,
- check::LiveSymbols, eval::Call> {
-public:
- void checkASTDecl(const TranslationUnitDecl *D, AnalysisManager &Mgr,
- BugReporter &BR) const;
- void checkBeginFunction(CheckerContext &C) const;
- void checkLiveSymbols(ProgramStateRef State, SymbolReaper &SR) const;
- bool evalCall(const CallEvent &Call, CheckerContext &C) const;
-
- // The declaration of an "errno" variable or "errno location" function.
- static const Decl *ErrnoDecl;
-
-private:
- // FIXME: Names from `ErrnoLocationFuncNames` are used to build this set.
- CallDescriptionSet ErrnoLocationCalls{{"__errno_location", 0, 0},
- {"___errno", 0, 0},
- {"__errno", 0, 0},
- {"_errno", 0, 0},
- {"__error", 0, 0}};
-};
-
-} // namespace
-
-/// Store a MemRegion that contains the 'errno' integer value.
-/// The value is null if the 'errno' value was not recognized in the AST.
-REGISTER_TRAIT_WITH_PROGRAMSTATE(ErrnoRegion, const void *)
-
-/// An internal function accessing the errno region.
-/// Returns null if there isn't any associated memory region.
-static const MemRegion *getErrnoRegion(ProgramStateRef State) {
- return reinterpret_cast<const MemRegion *>(State->get<ErrnoRegion>());
-}
-
-/// Search for a variable called "errno" in the AST.
-/// Return nullptr if not found.
-static const VarDecl *getErrnoVar(ASTContext &ACtx) {
- IdentifierInfo &II = ACtx.Idents.get(ErrnoVarName);
- auto LookupRes = ACtx.getTranslationUnitDecl()->lookup(&II);
- auto Found = llvm::find_if(LookupRes, [&ACtx](const Decl *D) {
- if (auto *VD = dyn_cast<VarDecl>(D))
- return ACtx.getSourceManager().isInSystemHeader(VD->getLocation()) &&
- VD->hasExternalStorage() &&
- VD->getType().getCanonicalType() == ACtx.IntTy;
- return false;
- });
- if (Found == LookupRes.end())
- return nullptr;
-
- return cast<VarDecl>(*Found);
-}
-
-/// Search for a function with a specific name that is used to return a pointer
-/// to "errno".
-/// Return nullptr if no such function was found.
-static const FunctionDecl *getErrnoFunc(ASTContext &ACtx) {
- SmallVector<const Decl *> LookupRes;
- for (StringRef ErrnoName : ErrnoLocationFuncNames) {
- IdentifierInfo &II = ACtx.Idents.get(ErrnoName);
- llvm::append_range(LookupRes, ACtx.getTranslationUnitDecl()->lookup(&II));
- }
-
- auto Found = llvm::find_if(LookupRes, [&ACtx](const Decl *D) {
- if (auto *FD = dyn_cast<FunctionDecl>(D))
- return ACtx.getSourceManager().isInSystemHeader(FD->getLocation()) &&
- FD->isExternC() && FD->getNumParams() == 0 &&
- FD->getReturnType().getCanonicalType() ==
- ACtx.getPointerType(ACtx.IntTy);
- return false;
- });
- if (Found == LookupRes.end())
- return nullptr;
-
- return cast<FunctionDecl>(*Found);
-}
-
-const Decl *ErrnoModeling::ErrnoDecl = nullptr;
-
-void ErrnoModeling::checkASTDecl(const TranslationUnitDecl *D,
- AnalysisManager &Mgr, BugReporter &BR) const {
- // Try to find an usable `errno` value.
- // It can be an external variable called "errno" or a function that returns a
- // pointer to the "errno" value. This function can have
diff erent names.
- // The actual case is dependent on the C library implementation, we
- // can only search for a match in one of these variations.
- // We assume that exactly one of these cases might be true.
- assert(!ErrnoDecl && "Checker should be used for one translation unit.");
-
- ErrnoDecl = getErrnoVar(Mgr.getASTContext());
- if (!ErrnoDecl)
- ErrnoDecl = getErrnoFunc(Mgr.getASTContext());
-}
-
-void ErrnoModeling::checkBeginFunction(CheckerContext &C) const {
- if (!C.inTopFrame())
- return;
-
- ASTContext &ACtx = C.getASTContext();
- ProgramStateRef State = C.getState();
-
- if (const auto *ErrnoVar = dyn_cast_or_null<VarDecl>(ErrnoDecl)) {
- // There is an external 'errno' variable.
- // Use its memory region.
- // The memory region for an 'errno'-like variable is allocated in system
- // space by MemRegionManager.
- const MemRegion *ErrnoR =
- State->getRegion(ErrnoVar, C.getLocationContext());
- assert(ErrnoR && "Memory region should exist for the 'errno' variable.");
- State = State->set<ErrnoRegion>(ErrnoR);
- State = errno_modeling::setErrnoValue(State, C, 0);
- C.addTransition(State);
- } else if (ErrnoDecl) {
- assert(isa<FunctionDecl>(ErrnoDecl) && "Invalid errno location function.");
- // There is a function that returns the location of 'errno'.
- // We must create a memory region for it in system space.
- // Currently a symbolic region is used with an artifical symbol.
- // FIXME: It is better to have a custom (new) kind of MemRegion for such
- // cases.
- SValBuilder &SVB = C.getSValBuilder();
- MemRegionManager &RMgr = C.getStateManager().getRegionManager();
-
- const MemSpaceRegion *GlobalSystemSpace =
- RMgr.getGlobalsRegion(MemRegion::GlobalSystemSpaceRegionKind);
-
- // Create an artifical symbol for the region.
- // It is not possible to associate a statement or expression in this case.
- const SymbolConjured *Sym = SVB.conjureSymbol(
- nullptr, C.getLocationContext(),
- ACtx.getLValueReferenceType(ACtx.IntTy), C.blockCount(), &ErrnoDecl);
-
- // The symbolic region is untyped, create a typed sub-region in it.
- // The ElementRegion is used to make the errno region a typed region.
- const MemRegion *ErrnoR = RMgr.getElementRegion(
- ACtx.IntTy, SVB.makeZeroArrayIndex(),
- RMgr.getSymbolicRegion(Sym, GlobalSystemSpace), C.getASTContext());
- State = State->set<ErrnoRegion>(ErrnoR);
- State = errno_modeling::setErrnoValue(State, C, 0);
- C.addTransition(State);
- }
-}
-
-bool ErrnoModeling::evalCall(const CallEvent &Call, CheckerContext &C) const {
- // Return location of "errno" at a call to an "errno address returning"
- // function.
- if (ErrnoLocationCalls.contains(Call)) {
- ProgramStateRef State = C.getState();
-
- const MemRegion *ErrnoR = getErrnoRegion(State);
- if (!ErrnoR)
- return false;
-
- State = State->BindExpr(Call.getOriginExpr(), C.getLocationContext(),
- loc::MemRegionVal{ErrnoR});
- C.addTransition(State);
- return true;
- }
-
- return false;
-}
-
-void ErrnoModeling::checkLiveSymbols(ProgramStateRef State,
- SymbolReaper &SR) const {
- // The special errno region should never garbage collected.
- if (const auto *ErrnoR = getErrnoRegion(State))
- SR.markLive(ErrnoR);
-}
-
-namespace clang {
-namespace ento {
-namespace errno_modeling {
-
-Optional<SVal> getErrnoValue(ProgramStateRef State) {
- const MemRegion *ErrnoR = getErrnoRegion(State);
- if (!ErrnoR)
- return {};
- QualType IntTy = State->getAnalysisManager().getASTContext().IntTy;
- return State->getSVal(ErrnoR, IntTy);
-}
-
-ProgramStateRef setErrnoValue(ProgramStateRef State,
- const LocationContext *LCtx, SVal Value) {
- const MemRegion *ErrnoR = getErrnoRegion(State);
- if (!ErrnoR)
- return State;
- return State->bindLoc(loc::MemRegionVal{ErrnoR}, Value, LCtx);
-}
-
-ProgramStateRef setErrnoValue(ProgramStateRef State, CheckerContext &C,
- uint64_t Value) {
- const MemRegion *ErrnoR = getErrnoRegion(State);
- if (!ErrnoR)
- return State;
- return State->bindLoc(
- loc::MemRegionVal{ErrnoR},
- C.getSValBuilder().makeIntVal(Value, C.getASTContext().IntTy),
- C.getLocationContext());
-}
-
-} // namespace errno_modeling
-} // namespace ento
-} // namespace clang
-
-void ento::registerErrnoModeling(CheckerManager &mgr) {
- mgr.registerChecker<ErrnoModeling>();
-}
-
-bool ento::shouldRegisterErrnoModeling(const CheckerManager &mgr) {
- return true;
-}
diff --git a/clang/lib/StaticAnalyzer/Checkers/ErrnoTesterChecker.cpp b/clang/lib/StaticAnalyzer/Checkers/ErrnoTesterChecker.cpp
deleted file mode 100644
index 62d536e54ec37..0000000000000
--- a/clang/lib/StaticAnalyzer/Checkers/ErrnoTesterChecker.cpp
+++ /dev/null
@@ -1,120 +0,0 @@
-//=== ErrnoTesterChecker.cpp ------------------------------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-//
-// This defines ErrnoTesterChecker, which is used to test functionality of the
-// errno_check API.
-//
-//===----------------------------------------------------------------------===//
-
-#include "Errno.h"
-#include "clang/StaticAnalyzer/Checkers/BuiltinCheckerRegistration.h"
-#include "clang/StaticAnalyzer/Core/Checker.h"
-#include "clang/StaticAnalyzer/Core/CheckerManager.h"
-#include "clang/StaticAnalyzer/Core/PathSensitive/CallDescription.h"
-#include "clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h"
-
-using namespace clang;
-using namespace ento;
-
-namespace {
-
-class ErrnoTesterChecker : public Checker<eval::Call> {
-public:
- bool evalCall(const CallEvent &Call, CheckerContext &C) const;
-
-private:
- static void evalSetErrno(CheckerContext &C, const CallEvent &Call);
- static void evalGetErrno(CheckerContext &C, const CallEvent &Call);
- static void evalSetErrnoIfError(CheckerContext &C, const CallEvent &Call);
- static void evalSetErrnoIfErrorRange(CheckerContext &C,
- const CallEvent &Call);
-
- using EvalFn = std::function<void(CheckerContext &, const CallEvent &)>;
- const CallDescriptionMap<EvalFn> TestCalls{
- {{"ErrnoTesterChecker_setErrno", 1}, &ErrnoTesterChecker::evalSetErrno},
- {{"ErrnoTesterChecker_getErrno", 0}, &ErrnoTesterChecker::evalGetErrno},
- {{"ErrnoTesterChecker_setErrnoIfError", 0},
- &ErrnoTesterChecker::evalSetErrnoIfError},
- {{"ErrnoTesterChecker_setErrnoIfErrorRange", 0},
- &ErrnoTesterChecker::evalSetErrnoIfErrorRange}};
-};
-
-} // namespace
-
-void ErrnoTesterChecker::evalSetErrno(CheckerContext &C,
- const CallEvent &Call) {
- C.addTransition(errno_modeling::setErrnoValue(
- C.getState(), C.getLocationContext(), Call.getArgSVal(0)));
-}
-
-void ErrnoTesterChecker::evalGetErrno(CheckerContext &C,
- const CallEvent &Call) {
- ProgramStateRef State = C.getState();
-
- Optional<SVal> ErrnoVal = errno_modeling::getErrnoValue(State);
- assert(ErrnoVal && "Errno value should be available.");
- State =
- State->BindExpr(Call.getOriginExpr(), C.getLocationContext(), *ErrnoVal);
-
- C.addTransition(State);
-}
-
-void ErrnoTesterChecker::evalSetErrnoIfError(CheckerContext &C,
- const CallEvent &Call) {
- ProgramStateRef State = C.getState();
- SValBuilder &SVB = C.getSValBuilder();
-
- ProgramStateRef StateSuccess = State->BindExpr(
- Call.getOriginExpr(), C.getLocationContext(), SVB.makeIntVal(0, true));
-
- ProgramStateRef StateFailure = State->BindExpr(
- Call.getOriginExpr(), C.getLocationContext(), SVB.makeIntVal(1, true));
- StateFailure = errno_modeling::setErrnoValue(StateFailure, C, 11);
-
- C.addTransition(StateSuccess);
- C.addTransition(StateFailure);
-}
-
-void ErrnoTesterChecker::evalSetErrnoIfErrorRange(CheckerContext &C,
- const CallEvent &Call) {
- ProgramStateRef State = C.getState();
- SValBuilder &SVB = C.getSValBuilder();
-
- ProgramStateRef StateSuccess = State->BindExpr(
- Call.getOriginExpr(), C.getLocationContext(), SVB.makeIntVal(0, true));
-
- ProgramStateRef StateFailure = State->BindExpr(
- Call.getOriginExpr(), C.getLocationContext(), SVB.makeIntVal(1, true));
- DefinedOrUnknownSVal ErrnoVal = SVB.conjureSymbolVal(
- nullptr, Call.getOriginExpr(), C.getLocationContext(), C.blockCount());
- StateFailure = StateFailure->assume(ErrnoVal, true);
- assert(StateFailure && "Failed to assume on an initial value.");
- StateFailure = errno_modeling::setErrnoValue(
- StateFailure, C.getLocationContext(), ErrnoVal);
-
- C.addTransition(StateSuccess);
- C.addTransition(StateFailure);
-}
-
-bool ErrnoTesterChecker::evalCall(const CallEvent &Call,
- CheckerContext &C) const {
- const EvalFn *Fn = TestCalls.lookup(Call);
- if (Fn) {
- (*Fn)(C, Call);
- return C.isDifferent();
- }
- return false;
-}
-
-void ento::registerErrnoTesterChecker(CheckerManager &Mgr) {
- Mgr.registerChecker<ErrnoTesterChecker>();
-}
-
-bool ento::shouldRegisterErrnoTesterChecker(const CheckerManager &Mgr) {
- return true;
-}
diff --git a/clang/lib/StaticAnalyzer/Core/MemRegion.cpp b/clang/lib/StaticAnalyzer/Core/MemRegion.cpp
index 6d0b5f85d84ed..58bea12f87836 100644
--- a/clang/lib/StaticAnalyzer/Core/MemRegion.cpp
+++ b/clang/lib/StaticAnalyzer/Core/MemRegion.cpp
@@ -1153,12 +1153,9 @@ MemRegionManager::getBlockCodeRegion(const BlockDecl *BD, CanQualType locTy,
return getSubRegion<BlockCodeRegion>(BD, locTy, AC, getCodeRegion());
}
-const SymbolicRegion *
-MemRegionManager::getSymbolicRegion(SymbolRef sym,
- const MemSpaceRegion *MemSpace) {
- if (MemSpace == nullptr)
- MemSpace = getUnknownRegion();
- return getSubRegion<SymbolicRegion>(sym, MemSpace);
+/// getSymbolicRegion - Retrieve or create a "symbolic" memory region.
+const SymbolicRegion *MemRegionManager::getSymbolicRegion(SymbolRef sym) {
+ return getSubRegion<SymbolicRegion>(sym, getUnknownRegion());
}
const SymbolicRegion *MemRegionManager::getSymbolicHeapRegion(SymbolRef Sym) {
diff --git a/clang/test/Analysis/Inputs/errno_func.h b/clang/test/Analysis/Inputs/errno_func.h
deleted file mode 100644
index a6c74b1a08d1e..0000000000000
--- a/clang/test/Analysis/Inputs/errno_func.h
+++ /dev/null
@@ -1,5 +0,0 @@
-#pragma clang system_header
-
-// Define 'errno' as a macro that calls a function.
-int *__errno_location();
-#define errno (*__errno_location())
diff --git a/clang/test/Analysis/Inputs/errno_var.h b/clang/test/Analysis/Inputs/errno_var.h
deleted file mode 100644
index 82b1e9bf6285d..0000000000000
--- a/clang/test/Analysis/Inputs/errno_var.h
+++ /dev/null
@@ -1,5 +0,0 @@
-#pragma clang system_header
-
-// Declare 'errno' as an extern variable in a system header.
-// This may be not allowed in C99.
-extern int errno;
diff --git a/clang/test/Analysis/Inputs/system-header-simulator.h b/clang/test/Analysis/Inputs/system-header-simulator.h
index 70345c5f4022d..b72f45a9b0e55 100644
--- a/clang/test/Analysis/Inputs/system-header-simulator.h
+++ b/clang/test/Analysis/Inputs/system-header-simulator.h
@@ -59,6 +59,9 @@ int feof(FILE *stream);
int ferror(FILE *stream);
int fileno(FILE *stream);
+// Note, on some platforms errno macro gets replaced with a function call.
+extern int errno;
+
size_t strlen(const char *);
char *strcpy(char *restrict, const char *restrict);
diff --git a/clang/test/Analysis/analyzer-enabled-checkers.c b/clang/test/Analysis/analyzer-enabled-checkers.c
index fa306d78d5553..7437e79a498f1 100644
--- a/clang/test/Analysis/analyzer-enabled-checkers.c
+++ b/clang/test/Analysis/analyzer-enabled-checkers.c
@@ -6,7 +6,6 @@
// CHECK: OVERVIEW: Clang Static Analyzer Enabled Checkers List
// CHECK-EMPTY:
-// CHECK-NEXT: apiModeling.Errno
// CHECK-NEXT: core.CallAndMessageModeling
// CHECK-NEXT: apiModeling.StdCLibraryFunctions
// CHECK-NEXT: apiModeling.TrustNonnull
diff --git a/clang/test/Analysis/errno.c b/clang/test/Analysis/errno.c
deleted file mode 100644
index c2697d8891b19..0000000000000
--- a/clang/test/Analysis/errno.c
+++ /dev/null
@@ -1,58 +0,0 @@
-// RUN: %clang_analyze_cc1 -verify %s \
-// RUN: -analyzer-checker=core \
-// RUN: -analyzer-checker=apiModeling.Errno \
-// RUN: -analyzer-checker=debug.ExprInspection \
-// RUN: -analyzer-checker=debug.ErrnoTest \
-// RUN: -DERRNO_HEADER=\"Inputs/errno_var.h\"
-
-// RUN: %clang_analyze_cc1 -verify %s \
-// RUN: -analyzer-checker=core \
-// RUN: -analyzer-checker=apiModeling.Errno \
-// RUN: -analyzer-checker=debug.ExprInspection \
-// RUN: -analyzer-checker=debug.ErrnoTest \
-// RUN: -DERRNO_HEADER=\"Inputs/errno_func.h\"
-
-#include ERRNO_HEADER
-
-void clang_analyzer_eval(int);
-void ErrnoTesterChecker_setErrno(int);
-int ErrnoTesterChecker_getErrno();
-int ErrnoTesterChecker_setErrnoIfError();
-int ErrnoTesterChecker_setErrnoIfErrorRange();
-
-void something();
-
-void test() {
- // Test if errno is initialized.
- clang_analyzer_eval(errno == 0); // expected-warning{{TRUE}}
-
- ErrnoTesterChecker_setErrno(1);
- // Test if errno was recognized and changed.
- clang_analyzer_eval(errno == 1); // expected-warning{{TRUE}}
- clang_analyzer_eval(ErrnoTesterChecker_getErrno() == 1); // expected-warning{{TRUE}}
-
- something();
-
- // Test if errno was invalidated.
- clang_analyzer_eval(errno); // expected-warning{{UNKNOWN}}
- clang_analyzer_eval(ErrnoTesterChecker_getErrno()); // expected-warning{{UNKNOWN}}
-}
-
-void testRange(int X) {
- if (X > 0) {
- ErrnoTesterChecker_setErrno(X);
- clang_analyzer_eval(errno > 0); // expected-warning{{TRUE}}
- }
-}
-
-void testIfError() {
- if (ErrnoTesterChecker_setErrnoIfError())
- clang_analyzer_eval(errno == 11); // expected-warning{{TRUE}}
-}
-
-void testIfErrorRange() {
- if (ErrnoTesterChecker_setErrnoIfErrorRange()) {
- clang_analyzer_eval(errno != 0); // expected-warning{{TRUE}}
- clang_analyzer_eval(errno == 1); // expected-warning{{FALSE}} expected-warning{{TRUE}}
- }
-}
diff --git a/clang/test/Analysis/global-region-invalidation.c b/clang/test/Analysis/global-region-invalidation.c
index 123f51fe633d7..74ff72cfae00d 100644
--- a/clang/test/Analysis/global-region-invalidation.c
+++ b/clang/test/Analysis/global-region-invalidation.c
@@ -1,15 +1,8 @@
-// RUN: %clang_analyze_cc1 -triple x86_64-apple-darwin10 -disable-free -verify %s \
-// RUN: -analyzer-checker=core,deadcode,alpha.security.taint,debug.TaintTest,debug.ExprInspection \
-// RUN: -DERRNO_HEADER=\"Inputs/errno_var.h\" %s
-
-// RUN: %clang_analyze_cc1 -triple x86_64-apple-darwin10 -disable-free -verify %s \
-// RUN: -analyzer-checker=core,deadcode,alpha.security.taint,debug.TaintTest,debug.ExprInspection \
-// RUN: -DERRNO_HEADER=\"Inputs/errno_func.h\"
+// RUN: %clang_analyze_cc1 -triple x86_64-apple-darwin10 -disable-free -analyzer-checker=core,deadcode,alpha.security.taint,debug.TaintTest,debug.ExprInspection -verify %s
void clang_analyzer_eval(int);
// Note, we do need to include headers here, since the analyzer checks if the function declaration is located in a system header.
-#include ERRNO_HEADER
#include "Inputs/system-header-simulator.h"
// Test that system header does not invalidate the internal global.
diff --git a/clang/test/Analysis/std-c-library-functions-arg-enabled-checkers.c b/clang/test/Analysis/std-c-library-functions-arg-enabled-checkers.c
index f00e10a0f056f..a64ec4a71487a 100644
--- a/clang/test/Analysis/std-c-library-functions-arg-enabled-checkers.c
+++ b/clang/test/Analysis/std-c-library-functions-arg-enabled-checkers.c
@@ -21,7 +21,6 @@
// CHECK-NEXT: alpha.unix.Stream
// CHECK-NEXT: apiModeling.StdCLibraryFunctions
// CHECK-NEXT: alpha.unix.StdCLibraryFunctionArgs
-// CHECK-NEXT: apiModeling.Errno
// CHECK-NEXT: apiModeling.TrustNonnull
// CHECK-NEXT: apiModeling.TrustReturnsNonnull
// CHECK-NEXT: apiModeling.llvm.CastValue
More information about the cfe-commits
mailing list