[StaticAnalyzer] Fix some Clang-tidy modernize and Include What You Use... (6405f2f9) · Commits · llvm-doe / llvm-project

clang/include/clang/StaticAnalyzer/Core/PathSensitive/ProgramStateTrait.h

+68 −74

Original line number	Diff line number	Diff line
		@@ -14,33 +14,28 @@
		//
		//===----------------------------------------------------------------------===//


		#ifndef LLVM_CLANG_STATICANALYZER_CORE_PATHSENSITIVE_PROGRAMSTATETRAIT_H
		#define LLVM_CLANG_STATICANALYZER_CORE_PATHSENSITIVE_PROGRAMSTATETRAIT_H

		#include "llvm/ADT/ImmutableList.h"
		#include "llvm/ADT/ImmutableMap.h"
		#include "llvm/ADT/ImmutableSet.h"
		#include "llvm/Support/Allocator.h"
		#include "llvm/Support/DataTypes.h"

		namespace llvm {
		template <typename K, typename D, typename I> class ImmutableMap;
		template <typename K, typename I> class ImmutableSet;
		template <typename T> class ImmutableList;
		template <typename T> class ImmutableListImpl;
		}
		#include <cstdint>

		namespace clang {

		namespace ento {

		template <typename T> struct ProgramStatePartialTrait;

		/// Declares a program state trait for type \p Type called \p Name, and
		/// introduce a typedef named \c NameTy.
		/// introduce a type named \c NameTy.
		/// The macro should not be used inside namespaces, or for traits that must
		/// be accessible from more than one translation unit.
		#define REGISTER_TRAIT_WITH_PROGRAMSTATE(Name, Type) \
		namespace { \
		class Name {}; \
		typedef Type Name ## Ty; \
		using Name ## Ty = Type; \
		} \
		namespace clang { \
		namespace ento { \
		@@ -52,28 +47,30 @@ namespace ento {
		} \
		}


		// Partial-specialization for ImmutableMap.

		template <typename Key, typename Data, typename Info>
		struct ProgramStatePartialTrait<llvm::ImmutableMap<Key, Data, Info>> {
		typedef llvm::ImmutableMap<Key,Data,Info> data_type;
		typedef typename data_type::Factory& context_type;
		typedef Key key_type;
		typedef Data value_type;
		typedef const value_type* lookup_type;
		using data_type = llvm::ImmutableMap<Key, Data, Info>;
		using context_type = typename data_type::Factory &;
		using key_type = Key;
		using value_type = Data;
		using lookup_type = const value_type *;

		static inline data_type MakeData(void const p) {
		static data_type MakeData(void const p) {
		return p ? data_type((typename data_type::TreeTy ) p)
		: data_type(nullptr);
		}
		static inline void *MakeVoidPtr(data_type B) {

		static void *MakeVoidPtr(data_type B) {
		return B.getRoot();
		}

		static lookup_type Lookup(data_type B, key_type K) {
		return B.lookup(K);
		}
		static data_type Set(data_type B, key_type K, value_type E,context_type F){

		static data_type Set(data_type B, key_type K, value_type E,
		context_type F) {
		return F.add(B, K, E);
		}

		@@ -85,7 +82,7 @@ namespace ento {
		return B.contains(K);
		}

		static inline context_type MakeContext(void *p) {
		static context_type MakeContext(void *p) {
		return ((typename data_type::Factory ) p);
		}

		@@ -107,21 +104,19 @@ namespace ento {
		/// can deal with.
		#define CLANG_ENTO_PROGRAMSTATE_MAP(Key, Value) llvm::ImmutableMap<Key, Value>


		// Partial-specialization for ImmutableSet.

		template <typename Key, typename Info>
		struct ProgramStatePartialTrait<llvm::ImmutableSet<Key, Info>> {
		typedef llvm::ImmutableSet<Key,Info> data_type;
		typedef typename data_type::Factory& context_type;
		typedef Key key_type;
		using data_type = llvm::ImmutableSet<Key, Info>;
		using context_type = typename data_type::Factory &;
		using key_type = Key;

		static inline data_type MakeData(void const p) {
		static data_type MakeData(void const p) {
		return p ? data_type((typename data_type::TreeTy ) p)
		: data_type(nullptr);
		}

		static inline void *MakeVoidPtr(data_type B) {
		static void *MakeVoidPtr(data_type B) {
		return B.getRoot();
		}

		@@ -137,7 +132,7 @@ namespace ento {
		return B.contains(K);
		}

		static inline context_type MakeContext(void *p) {
		static context_type MakeContext(void *p) {
		return ((typename data_type::Factory ) p);
		}

		@@ -150,14 +145,12 @@ namespace ento {
		}
		};


		// Partial-specialization for ImmutableList.

		template <typename T>
		struct ProgramStatePartialTrait<llvm::ImmutableList<T>> {
		typedef llvm::ImmutableList<T> data_type;
		typedef T key_type;
		typedef typename data_type::Factory& context_type;
		using data_type = llvm::ImmutableList<T>;
		using key_type = T;
		using context_type = typename data_type::Factory &;

		static data_type Add(data_type L, key_type K, context_type F) {
		return F.add(K, L);
		@@ -167,16 +160,16 @@ namespace ento {
		return L.contains(K);
		}

		static inline data_type MakeData(void const p) {
		static data_type MakeData(void const p) {
		return p ? data_type((const llvm::ImmutableListImpl<T> ) p)
		: data_type(nullptr);
		}

		static inline void *MakeVoidPtr(data_type D) {
		static void *MakeVoidPtr(data_type D) {
		return const_cast<llvm::ImmutableListImpl<T> *>(D.getInternalPointer());
		}

		static inline context_type MakeContext(void *p) {
		static context_type MakeContext(void *p) {
		return ((typename data_type::Factory ) p);
		}

		@@ -189,61 +182,62 @@ namespace ento {
		}
		};


		// Partial specialization for bool.
		template <> struct ProgramStatePartialTrait<bool> {
		typedef bool data_type;
		using data_type = bool;

		static inline data_type MakeData(void const p) {
		static data_type MakeData(void const p) {
		return p ? (data_type) (uintptr_t) *p
		: data_type();
		}
		static inline void *MakeVoidPtr(data_type d) {

		static void *MakeVoidPtr(data_type d) {
		return (void *) (uintptr_t) d;
		}
		};

		// Partial specialization for unsigned.
		template <> struct ProgramStatePartialTrait<unsigned> {
		typedef unsigned data_type;
		using data_type = unsigned;

		static inline data_type MakeData(void const p) {
		static data_type MakeData(void const p) {
		return p ? (data_type) (uintptr_t) *p
		: data_type();
		}
		static inline void *MakeVoidPtr(data_type d) {

		static void *MakeVoidPtr(data_type d) {
		return (void *) (uintptr_t) d;
		}
		};

		// Partial specialization for void*.
		template <> struct ProgramStatePartialTrait<void *> {
		typedef void *data_type;
		using data_type = void *;

		static inline data_type MakeData(void const p) {
		static data_type MakeData(void const p) {
		return p ? *p
		: data_type();
		}
		static inline void *MakeVoidPtr(data_type d) {

		static void *MakeVoidPtr(data_type d) {
		return d;
		}
		};

		// Partial specialization for const void *.
		template <> struct ProgramStatePartialTrait<const void *> {
		typedef const void *data_type;
		using data_type = const void *;

		static inline data_type MakeData(void * const *p) {
		static data_type MakeData(void const p) {
		return p ? *p : data_type();
		}

		static inline void *MakeVoidPtr(data_type d) {
		static void *MakeVoidPtr(data_type d) {
		return const_cast<void *>(d);
		}
		};

		} // end ento namespace

		} // end clang namespace
		} // namespace ento
		} // namespace clang

		#endif
		#endif // LLVM_CLANG_STATICANALYZER_CORE_PATHSENSITIVE_PROGRAMSTATETRAIT_H

clang/include/clang/StaticAnalyzer/Core/PathSensitive/SValBuilder.h

+29 −11

Original line number	Diff line number	Diff line
		@@ -16,23 +16,43 @@
		#define LLVM_CLANG_STATICANALYZER_CORE_PATHSENSITIVE_SVALBUILDER_H

		#include "clang/AST/ASTContext.h"
		#include "clang/AST/DeclarationName.h"
		#include "clang/AST/Expr.h"
		#include "clang/AST/ExprObjC.h"
		#include "clang/AST/Type.h"
		#include "clang/Basic/LLVM.h"
		#include "clang/Basic/LangOptions.h"
		#include "clang/StaticAnalyzer/Core/PathSensitive/BasicValueFactory.h"
		#include "clang/StaticAnalyzer/Core/PathSensitive/MemRegion.h"
		#include "clang/StaticAnalyzer/Core/PathSensitive/ProgramState_Fwd.h"
		#include "clang/StaticAnalyzer/Core/PathSensitive/SVals.h"
		#include "clang/StaticAnalyzer/Core/PathSensitive/SymExpr.h"
		#include "clang/StaticAnalyzer/Core/PathSensitive/SymbolManager.h"
		#include "llvm/ADT/ImmutableList.h"
		#include "llvm/ADT/Optional.h"
		#include <cstdint>

		namespace clang {

		class BlockDecl;
		class CXXBoolLiteralExpr;
		class CXXMethodDecl;
		class CXXRecordDecl;
		class DeclaratorDecl;
		class FunctionDecl;
		class LocationContext;
		class StackFrameContext;
		class Stmt;

		namespace ento {

		class ConditionTruthVal;
		class ProgramStateManager;
		class StoreRef;

		class SValBuilder {
		virtual void anchor();

		protected:
		ASTContext &Context;

		@@ -65,13 +85,11 @@ public:
		SValBuilder(llvm::BumpPtrAllocator &alloc, ASTContext &context,
		ProgramStateManager &stateMgr)
		: Context(context), BasicVals(context, alloc),
		SymMgr(context, BasicVals, alloc),
		MemMgr(context, alloc),
		StateMgr(stateMgr),
		ArrayIndexTy(context.LongLongTy),
		SymMgr(context, BasicVals, alloc), MemMgr(context, alloc),
		StateMgr(stateMgr), ArrayIndexTy(context.LongLongTy),
		ArrayIndexWidth(context.getTypeSize(ArrayIndexTy)) {}

		virtual ~SValBuilder() {}
		virtual ~SValBuilder() = default;

		bool haveSameType(const SymExpr Sym1, const SymExpr Sym2) {
		return haveSameType(Sym1->getType(), Sym2->getType());
		@@ -195,11 +213,11 @@ public:
		const LocationContext *LCtx,
		QualType type,
		unsigned count);

		DefinedOrUnknownSVal conjureSymbolVal(const Stmt *stmt,
		const LocationContext *LCtx,
		QualType type,
		unsigned visitCount);

		/// \brief Conjure a symbol representing heap allocated memory region.
		///
		/// Note, the expression should represent a location.
		@@ -362,8 +380,8 @@ SValBuilder* createSimpleSValBuilder(llvm::BumpPtrAllocator &alloc,
		ASTContext &context,
		ProgramStateManager &stateMgr);

		} // end GR namespace
		} // namespace ento

		} // end clang namespace
		} // namespace clang

		#endif
		#endif // LLVM_CLANG_STATICANALYZER_CORE_PATHSENSITIVE_SVALBUILDER_H

clang/include/clang/StaticAnalyzer/Core/PathSensitive/SVals.h

+124 −79

Original line number	Diff line number	Diff line
		//== SVals.h - Abstract Values for Static Analysis ---------- C++ ---==//
		//===- SVals.h - Abstract Values for Static Analysis ------------- C++ --===//
		//
		// The LLVM Compiler Infrastructure
		//
		@@ -16,11 +16,18 @@
		#define LLVM_CLANG_STATICANALYZER_CORE_PATHSENSITIVE_SVALS_H

		#include "clang/AST/Expr.h"
		#include "clang/AST/Type.h"
		#include "clang/Basic/LLVM.h"
		#include "clang/StaticAnalyzer/Core/PathSensitive/ProgramState_Fwd.h"
		#include "clang/StaticAnalyzer/Core/PathSensitive/SymExpr.h"
		#include "llvm/ADT/FoldingSet.h"
		#include "llvm/ADT/ImmutableList.h"
		#include "llvm/ADT/None.h"
		#include "llvm/ADT/Optional.h"
		#include "llvm/ADT/PointerUnion.h"
		#include "llvm/Support/Casting.h"
		#include <cassert>
		#include <cstdint>
		#include <utility>

		//==------------------------------------------------------------------------==//
		// Base SVal types.
		@@ -28,34 +35,40 @@

		namespace clang {

		class CXXBaseSpecifier;
		class DeclaratorDecl;
		class FunctionDecl;
		class LabelDecl;

		namespace ento {

		class BasicValueFactory;
		class CompoundValData;
		class LazyCompoundValData;
		class PointerToMemberData;
		class ProgramState;
		class BasicValueFactory;
		class MemRegion;
		class TypedValueRegion;
		class MemRegionManager;
		class ProgramStateManager;
		class PointerToMemberData;
		class SValBuilder;
		class TypedValueRegion;

		namespace nonloc {

		/// Sub-kinds for NonLoc values.
		enum Kind {
		#define NONLOC_SVAL(Id, Parent) Id ## Kind,
		#include "clang/StaticAnalyzer/Core/PathSensitive/SVals.def"
		};
		}

		} // namespace nonloc

		namespace loc {

		/// Sub-kinds for Loc values.
		enum Kind {
		#define LOC_SVAL(Id, Parent) Id ## Kind,
		#include "clang/StaticAnalyzer/Core/PathSensitive/SVals.def"
		};
		}

		} // namespace loc

		/// SVal - This represents a symbolic expression, which can be either
		/// an L-value or an R-value.
		@@ -71,20 +84,19 @@ public:
		enum { BaseBits = 2, BaseMask = 0x3 };

		protected:
		const void *Data;
		const void *Data = nullptr;

		/// The lowest 2 bits are a BaseKind (0 -- 3).
		/// The higher bits are an unsigned "kind" value.
		unsigned Kind;
		unsigned Kind = 0;

		explicit SVal(const void *d, bool isLoc, unsigned ValKind)
		: Data(d), Kind((isLoc ? LocKind : NonLocKind) \| (ValKind << BaseBits)) {}

		explicit SVal(BaseKind k, const void *D = nullptr)
		: Data(D), Kind(k) {}
		explicit SVal(BaseKind k, const void *D = nullptr) : Data(D), Kind(k) {}

		public:
		explicit SVal() : Data(nullptr), Kind(0) {}
		explicit SVal() = default;

		/// \brief Convert to the specified SVal type, asserting that this SVal is of
		/// the desired type.
		@@ -103,38 +115,38 @@ public:
		return static_cast<const T >(this);
		}

		inline unsigned getRawKind() const { return Kind; }
		inline BaseKind getBaseKind() const { return (BaseKind) (Kind & BaseMask); }
		inline unsigned getSubKind() const { return (Kind & ~BaseMask) >> BaseBits; }
		unsigned getRawKind() const { return Kind; }
		BaseKind getBaseKind() const { return (BaseKind) (Kind & BaseMask); }
		unsigned getSubKind() const { return (Kind & ~BaseMask) >> BaseBits; }

		// This method is required for using SVal in a FoldingSetNode. It
		// extracts a unique signature for this SVal object.
		inline void Profile(llvm::FoldingSetNodeID& ID) const {
		void Profile(llvm::FoldingSetNodeID &ID) const {
		ID.AddInteger((unsigned) getRawKind());
		ID.AddPointer(Data);
		}

		inline bool operator==(const SVal& R) const {
		bool operator==(const SVal &R) const {
		return getRawKind() == R.getRawKind() && Data == R.Data;
		}

		inline bool operator!=(const SVal& R) const {
		bool operator!=(const SVal &R) const {
		return !(*this == R);
		}

		inline bool isUnknown() const {
		bool isUnknown() const {
		return getRawKind() == UnknownValKind;
		}

		inline bool isUndef() const {
		bool isUndef() const {
		return getRawKind() == UndefinedValKind;
		}

		inline bool isUnknownOrUndef() const {
		bool isUnknownOrUndef() const {
		return getRawKind() <= UnknownValKind;
		}

		inline bool isValid() const {
		bool isValid() const {
		return getRawKind() > UnknownValKind;
		}

		@@ -206,28 +218,28 @@ public:

		private:
		friend class SVal;

		static bool isKind(const SVal& V) {
		return V.getBaseKind() == UndefinedValKind;
		}
		};

		class DefinedOrUnknownSVal : public SVal {
		private:
		public:
		// We want calling these methods to be a compiler error since they are
		// tautologically false.
		bool isUndef() const = delete;
		bool isValid() const = delete;

		protected:
		DefinedOrUnknownSVal() {}
		DefinedOrUnknownSVal() = default;
		explicit DefinedOrUnknownSVal(const void *d, bool isLoc, unsigned ValKind)
		: SVal(d, isLoc, ValKind) {}

		explicit DefinedOrUnknownSVal(BaseKind k, void *D = nullptr)
		: SVal(k, D) {}
		explicit DefinedOrUnknownSVal(BaseKind k, void *D = nullptr) : SVal(k, D) {}

		private:
		friend class SVal;

		static bool isKind(const SVal& V) {
		return !V.isUndef();
		}
		@@ -239,37 +251,43 @@ public:

		private:
		friend class SVal;

		static bool isKind(const SVal &V) {
		return V.getBaseKind() == UnknownValKind;
		}
		};

		class DefinedSVal : public DefinedOrUnknownSVal {
		private:
		public:
		// We want calling these methods to be a compiler error since they are
		// tautologically true/false.
		bool isUnknown() const = delete;
		bool isUnknownOrUndef() const = delete;
		bool isValid() const = delete;

		protected:
		DefinedSVal() {}
		DefinedSVal() = default;
		explicit DefinedSVal(const void *d, bool isLoc, unsigned ValKind)
		: DefinedOrUnknownSVal(d, isLoc, ValKind) {}

		private:
		friend class SVal;

		static bool isKind(const SVal& V) {
		return !V.isUnknownOrUndef();
		}
		};


		/// \brief Represents an SVal that is guaranteed to not be UnknownVal.
		class KnownSVal : public SVal {
		KnownSVal() {}
		friend class SVal;

		KnownSVal() = default;

		static bool isKind(const SVal &V) {
		return !V.isUnknown();
		}

		public:
		KnownSVal(const DefinedSVal &V) : SVal(V) {}
		KnownSVal(const UndefinedVal &V) : SVal(V) {}
		@@ -277,20 +295,21 @@ public:

		class NonLoc : public DefinedSVal {
		protected:
		NonLoc() {}
		NonLoc() = default;
		explicit NonLoc(unsigned SubKind, const void *d)
		: DefinedSVal(d, false, SubKind) {}

		public:
		void dumpToStream(raw_ostream &Out) const;

		static inline bool isCompoundType(QualType T) {
		static bool isCompoundType(QualType T) {
		return T->isArrayType() \|\| T->isRecordType() \|\|
		T->isComplexType() \|\| T->isVectorType();
		}

		private:
		friend class SVal;

		static bool isKind(const SVal& V) {
		return V.getBaseKind() == NonLocKind;
		}
		@@ -298,20 +317,21 @@ private:

		class Loc : public DefinedSVal {
		protected:
		Loc() {}
		Loc() = default;
		explicit Loc(unsigned SubKind, const void *D)
		: DefinedSVal(const_cast<void *>(D), true, SubKind) {}

		public:
		void dumpToStream(raw_ostream &Out) const;

		static inline bool isLocType(QualType T) {
		static bool isLocType(QualType T) {
		return T->isAnyPointerType() \|\| T->isBlockPointerType() \|\|
		T->isReferenceType() \|\| T->isNullPtrType();
		}

		private:
		friend class SVal;

		static bool isKind(const SVal& V) {
		return V.getBaseKind() == LocKind;
		}
		@@ -339,6 +359,7 @@ public:

		private:
		friend class SVal;

		static bool isKind(const SVal& V) {
		return V.getBaseKind() == NonLocKind &&
		V.getSubKind() == SymbolValKind;
		@@ -368,7 +389,9 @@ public:

		private:
		friend class SVal;
		ConcreteInt() {}

		ConcreteInt() = default;

		static bool isKind(const SVal& V) {
		return V.getBaseKind() == NonLocKind &&
		V.getSubKind() == ConcreteIntKind;
		@@ -392,7 +415,6 @@ class LocAsInteger : public NonLoc {
		}

		public:

		Loc getLoc() const {
		const std::pair<SVal, uintptr_t> *D =
		static_cast<const std::pair<SVal, uintptr_t> *>(Data);
		@@ -414,7 +436,9 @@ public:

		private:
		friend class SVal;
		LocAsInteger() {}

		LocAsInteger() = default;

		static bool isKind(const SVal& V) {
		return V.getBaseKind() == NonLocKind &&
		V.getSubKind() == LocAsIntegerKind;
		@@ -435,13 +459,16 @@ public:
		return static_cast<const CompoundValData *>(Data);
		}

		typedef llvm::ImmutableList<SVal>::iterator iterator;
		using iterator = llvm::ImmutableList<SVal>::iterator;

		iterator begin() const;
		iterator end() const;

		private:
		friend class SVal;
		CompoundVal() {}

		CompoundVal() = default;

		static bool isKind(const SVal& V) {
		return V.getBaseKind() == NonLocKind && V.getSubKind() == CompoundValKind;
		}
		@@ -456,20 +483,25 @@ class LazyCompoundVal : public NonLoc {

		explicit LazyCompoundVal(const LazyCompoundValData *D)
		: NonLoc(LazyCompoundValKind, D) {}

		public:
		const LazyCompoundValData *getCVData() const {
		return static_cast<const LazyCompoundValData *>(Data);
		}

		const void *getStore() const;
		const TypedValueRegion *getRegion() const;

		private:
		friend class SVal;
		LazyCompoundVal() {}

		LazyCompoundVal() = default;

		static bool isKind(const SVal& V) {
		return V.getBaseKind() == NonLocKind &&
		V.getSubKind() == LazyCompoundValKind;
		}

		static bool isKind(const NonLoc& V) {
		return V.getSubKind() == LazyCompoundValKind;
		}
		@@ -488,28 +520,36 @@ class PointerToMember : public NonLoc {
		friend class ento::SValBuilder;

		public:
		typedef llvm::PointerUnion<const DeclaratorDecl *,
		const PointerToMemberData *> PTMDataType;
		using PTMDataType =
		llvm::PointerUnion<const DeclaratorDecl , const PointerToMemberData >;

		const PTMDataType getPTMData() const {
		return PTMDataType::getFromOpaqueValue(const_cast<void *>(Data));
		}

		bool isNullMemberPointer() const {
		return getPTMData().isNull();
		}

		const DeclaratorDecl *getDecl() const;

		template<typename AdjustedDecl>
		const AdjustedDecl *getDeclAs() const {
		return dyn_cast_or_null<AdjustedDecl>(getDecl());
		}
		typedef llvm::ImmutableList<const CXXBaseSpecifier *>::iterator iterator;

		using iterator = llvm::ImmutableList<const CXXBaseSpecifier *>::iterator;

		iterator begin() const;
		iterator end() const;

		private:
		friend class SVal;

		PointerToMember() = default;
		explicit PointerToMember(const PTMDataType D)
		: NonLoc(PointerToMemberKind, D.getOpaqueValue()) {}
		friend class SVal;
		PointerToMember() {}

		static bool isKind(const SVal& V) {
		return V.getBaseKind() == NonLocKind &&
		V.getSubKind() == PointerToMemberKind;
		@@ -520,7 +560,7 @@ private:
		}
		};

		} // end namespace ento::nonloc
		} // namespace nonloc

		//==------------------------------------------------------------------------==//
		// Subclasses of Loc.
		@@ -540,7 +580,9 @@ public:

		private:
		friend class SVal;
		GotoLabel() {}

		GotoLabel() = default;

		static bool isKind(const SVal& V) {
		return V.getBaseKind() == LocKind && V.getSubKind() == GotoLabelKind;
		}
		@@ -550,7 +592,6 @@ private:
		}
		};


		class MemRegionVal : public Loc {
		public:
		explicit MemRegionVal(const MemRegion* r) : Loc(MemRegionValKind, r) {
		@@ -570,17 +611,19 @@ public:
		return dyn_cast<REGION>(getRegion());
		}

		inline bool operator==(const MemRegionVal& R) const {
		bool operator==(const MemRegionVal &R) const {
		return getRegion() == R.getRegion();
		}

		inline bool operator!=(const MemRegionVal& R) const {
		bool operator!=(const MemRegionVal &R) const {
		return getRegion() != R.getRegion();
		}

		private:
		friend class SVal;
		MemRegionVal() {}

		MemRegionVal() = default;

		static bool isKind(const SVal& V) {
		return V.getBaseKind() == LocKind &&
		V.getSubKind() == MemRegionValKind;
		@@ -605,7 +648,9 @@ public:

		private:
		friend class SVal;
		ConcreteInt() {}

		ConcreteInt() = default;

		static bool isKind(const SVal& V) {
		return V.getBaseKind() == LocKind &&
		V.getSubKind() == ConcreteIntKind;
		@@ -616,11 +661,11 @@ private:
		}
		};

		} // end ento::loc namespace
		} // namespace loc

		} // end ento namespace
		} // namespace ento

		} // end clang namespace
		} // namespace clang

		namespace llvm {

		@@ -629,6 +674,6 @@ template <> struct isPodLike<clang::ento::SVal> {
		static const bool value = true;
		};

		} // end llvm namespace
		} // namespace llvm

		#endif
		#endif // LLVM_CLANG_STATICANALYZER_CORE_PATHSENSITIVE_SVALS_H

clang/include/clang/StaticAnalyzer/Core/PathSensitive/SymbolManager.h

+43 −39

File changed.

Preview size limit exceeded, changes collapsed.

clang/lib/StaticAnalyzer/Core/SValBuilder.cpp

+31 −18

File changed.

Preview size limit exceeded, changes collapsed.