Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://clang.llvm.org/doxygen/RangeConstraintManager_8cpp_source.html below:

clang: lib/StaticAnalyzer/Core/RangeConstraintManager.cpp Source File

;

(BO_LT < BO_GT && BO_GT < BO_LE && BO_LE < BO_GE &&

BO_GE < BO_EQ && BO_EQ < BO_NE,

);

CmpOpCount = BO_NE - BO_LT + 1;

CmpOpTable[CmpOpCount][CmpOpCount + 1] = {

(OP - BO_LT);

CmpOpTable[getIndexFromOp(CurrentOP)][getIndexFromOp(QueriedOP)];

CmpOpTable[getIndexFromOp(CurrentOP)][CmpOpCount];

RangeSet::ContainerType RangeSet::Factory::EmptySet{};

std::back_inserter(

));

makePersistent(std::move(

));

.reserve(Original.size() + 1);

.insert(

.end(), Original.begin(), Lower);

.push_back(Element);

makePersistent(std::move(

));

add(Original,

(Point));

ContainerType

= unite(*LHS.Impl, *RHS.Impl);

makePersistent(std::move(

));

makePersistent(std::move(

));

unite(Original,

(ValueFactory.getValue(Point)));

unite(Original,

(ValueFactory.getValue(From), ValueFactory.getValue(To)));

<

T>

std::swap(

, Second);

std::swap(FirstEnd, SecondEnd);

ContainerType &RHS) {

iterator = ContainerType::const_iterator;

iterator

= LHS.begin();

iterator FirstEnd = LHS.end();

iterator Second = RHS.begin();

iterator SecondEnd = RHS.end();

(

==

->From() &&

== Second->From()) {

(

->To() > Second->To()) {

(++Second == SecondEnd)

(++

== FirstEnd)

AppendTheRest = [&

](iterator I, iterator

) {

(

->From() > Second->From())

llvm::APSInt &UnionStart =

->From();

(

->To() >= Second->To()) {

(++Second == SecondEnd) {

AppendTheRest(++

, FirstEnd);

(

->To() < Second->From() - One)

(++

== FirstEnd) {

.emplace_back(UnionStart, Second->To());

AppendTheRest(++Second, SecondEnd);

(++

== FirstEnd)

AppendTheRest(Second, SecondEnd);

llvm_unreachable(

);

makePersistent(std::move(

));

RangeSet::Factory::makePersistent(ContainerType &&From) {

llvm::FoldingSetNodeID ID;

ContainerType *

=

.FindNodeOrInsertPos(ID, InsertPos);

= construct(std::move(From));

RangeSet::ContainerType *RangeSet::Factory::construct(ContainerType &&From) {

*Buffer = Arena.Allocate();

(Buffer) ContainerType(std::move(From));

()->From();

std::prev(

())->To();

()->From().isUnsigned();

()->From().getBitWidth();

RangeSet::containsImpl(llvm::APSInt &Point)

{

(

() || !pin(Point))

std::prev(It)->Includes(Point);

RangeSet::pin(llvm::APSInt &Point)

{

RangeSet::pin(llvm::APSInt &Lower, llvm::APSInt &Upper)

{

Lower =

.getMinValue();

Upper =

.getMaxValue();

Lower =

.getMinValue();

Lower =

.getMinValue();

Upper =

.getMaxValue();

Upper =

.getMaxValue();

Upper =

.getMaxValue();

Lower =

.getMinValue();

Lower =

.getMinValue();

Upper =

.getMaxValue();

llvm::APSInt Upper) {

(What.

() || !What.pin(Lower, Upper))

getEmptySet();

ContainerType DummyContainer;

(Lower <= Upper) {

getEmptySet();

DummyContainer.push_back(

(ValueFactory.getValue(Lower), ValueFactory.getValue(Upper)));

getEmptySet();

DummyContainer.push_back(

(ValueFactory.getMinValue(Upper), ValueFactory.getValue(Upper)));

DummyContainer.push_back(

(ValueFactory.getValue(Lower), ValueFactory.getMaxValue(Lower)));

intersect(*What.Impl, DummyContainer);

RangeSet::ContainerType &RHS) {

.reserve(std::max(LHS.size(), RHS.size()));

FirstEnd = LHS.end(), SecondEnd = RHS.end();

(

!= FirstEnd && Second != SecondEnd) {

(Second->From() <

->From())

(Second->From() >

->To()) {

llvm::APSInt &IntersectionStart = Second->From();

(Second->To() >

->To()) {

.push_back(

(IntersectionStart, Second->To()));

}

(Second != SecondEnd);

getEmptySet();

makePersistent(std::move(

));

getEmptySet();

intersect(*LHS.Impl, *RHS.Impl);

(LHS.containsImpl(Point))

getRangeSet(ValueFactory.getValue(Point));

getEmptySet();

getEmptySet();

llvm::APSInt SampleValue = What.

();

llvm::APSInt &MIN = ValueFactory.getMinValue(SampleValue);

llvm::APSInt &MAX = ValueFactory.getMaxValue(SampleValue);

.reserve(What.

() + (SampleValue == MIN));

llvm::APSInt &From = It->From();

llvm::APSInt &To = It->To();

(

->To() == MAX) {

.emplace_back(MIN, ValueFactory.getValue(-

->From()));

.emplace_back(MIN, MIN);

.emplace_back(ValueFactory.getValue(-To), MAX);

(; It != End; ++It) {

llvm::APSInt &NewFrom = ValueFactory.getValue(-It->To());

llvm::APSInt &NewTo = ValueFactory.getValue(-It->From());

.emplace_back(NewFrom, NewTo);

makePersistent(std::move(

));

makePersistent(truncateTo(What, Ty));

(IsConversion && (!IsPromotion || !What.

()))

makePersistent(convertTo(What, Ty));

assert(IsPromotion &&

);

makePersistent(promoteTo(What, Ty));

RangeSet::ContainerType RangeSet::Factory::truncateTo(

What,

uint64_t CastRangeSize = APInt::getMaxValue(Ty.

()).getZExtValue();

(

&R : What) {

FromInt = R.From();

uint64_t CurrentRangeSize = (ToInt - FromInt).getZExtValue();

(CurrentRangeSize >= CastRangeSize) {

Dummy.emplace_back(ValueFactory.getMinValue(Ty),

ValueFactory.getMaxValue(Ty));

= std::move(Dummy);

&PersistentFrom = ValueFactory.getValue(FromInt);

&PersistentTo = ValueFactory.getValue(ToInt);

(FromInt > ToInt) {

Dummy.emplace_back(ValueFactory.getMinValue(Ty), PersistentTo);

Dummy.emplace_back(PersistentFrom, ValueFactory.getMaxValue(Ty));

Dummy.emplace_back(PersistentFrom, PersistentTo);

RangeSet::ContainerType RangeSet::Factory::convertTo(

What,

Bounds = std::pair<const APSInt &, const APSInt &>;

ContainerType AscendArray;

ContainerType DescendArray;

CastRange = [Ty, &VF = ValueFactory](

&R) -> Bounds {

FromInt = R.From();

{VF.getValue(FromInt), VF.getValue(ToInt)};

*It = What.

();

*

= What.

();

Bounds NewBounds = CastRange(*(It++));

(NewBounds.first < LastConvertedInt) {

DescendArray.emplace_back(NewBounds.first, NewBounds.second);

(NewBounds.first > NewBounds.second) {

DescendArray.emplace_back(ValueFactory.getMinValue(Ty), NewBounds.second);

AscendArray.emplace_back(NewBounds.first, ValueFactory.getMaxValue(Ty));

AscendArray.emplace_back(NewBounds.first, NewBounds.second);

LastConvertedInt = NewBounds.first;

Bounds NewBounds = CastRange(*(It++));

DescendArray.emplace_back(NewBounds.first, NewBounds.second);

unite(AscendArray, DescendArray);

RangeSet::ContainerType RangeSet::Factory::promoteTo(

What,

(

&R : What) {

llvm::APSInt FromInt = R.From();

llvm::APSInt ToInt = R.To();

.emplace_back(ValueFactory.getValue(FromInt),

ValueFactory.getValue(ToInt));

llvm::APSInt &Point) {

llvm::APSInt Upper = Point;

llvm::APSInt Lower = Point;

intersect(From, Upper, Lower);

llvm::interleaveComma(*

,

, [&

](

&R) { R.

(

); });

EquivalenceClass;

EquivalenceClass :

llvm::FoldingSetNode {

[[nodiscard]]

EquivalenceClass find(

State,

EquivalenceClass

, EquivalenceClass Second);

EquivalenceClass

)

;

[[nodiscard]]

ClassSet getDisequalClasses(

State,

[[nodiscard]]

ClassSet getDisequalClasses(

State)

;

[[nodiscard]]

ClassSet

getDisequalClasses(DisequalityMapTy Map, ClassSet::Factory &Factory)

;

[[nodiscard]]

std::optional<bool>

EquivalenceClass Second);

[[nodiscard]]

std::optional<bool>

EquivalenceClass Class);

dumpToStream(State, llvm::errs());

[[nodiscard]] LLVM_ATTRIBUTE_UNUSED

[[nodiscard]]

getType()

{

getRepresentativeSymbol()->getType();

EquivalenceClass() =

;

EquivalenceClass(

EquivalenceClass &) =

;

EquivalenceClass &operator=(

EquivalenceClass &) =

;

EquivalenceClass(EquivalenceClass &&) =

;

EquivalenceClass &operator=(EquivalenceClass &&) =

;

Profile(llvm::FoldingSetNodeID &

,

CID) {

.AddInteger(CID);

Profile(llvm::FoldingSetNodeID &

)

{ Profile(

, this->ID); }

getRepresentativeSymbol()

{

SymbolSet::Factory &getMembersFactory(

State);

addToDisequalityInfo(DisequalityMapTy &Info, ConstraintRangeTy &Constraints,

EquivalenceClass

, EquivalenceClass Second);

[[nodiscard]] LLVM_ATTRIBUTE_UNUSED

areFeasible(ConstraintRangeTy Constraints) {

llvm::none_of(

[](

std::pair<EquivalenceClass, RangeSet> &ClassConstraint) {

ClassConstraint.second.isEmpty();

EquivalenceClass Class) {

State->get<ConstraintRange>(

);

getConstraint(State, EquivalenceClass::find(State, Sym));

EquivalenceClass Class,

State->set<ConstraintRange>(

, Constraint);

ConstraintRangeTy Constraints) {

State->set<ConstraintRange>(Constraints);

std::optional<bool> meansEquality(

*Sym) {

std::nullopt;

<

SecondTy,

... RestTy>

SecondTy Second, RestTy... Tail);

<

... RangeTy>

IntersectionTraits;

<

... TailTy>

IntersectionTraits<

, TailTy...> {

<>

IntersectionTraits<> {

= std::optional<RangeSet>;

<

OptionalOrPointer,

... TailTy>

IntersectionTraits<OptionalOrPointer, TailTy...> {

=

IntersectionTraits<TailTy...>

;

<

EndTy>

[[nodiscard]] LLVM_ATTRIBUTE_UNUSED

std::optional<RangeSet>

std::nullopt;

<

... RestTy>

intersect(F, F.

(Head, Second), Tail...);

<

SecondTy,

... RestTy>

SecondTy Second, RestTy... Tail) {

intersect(F, Head, *Second, Tail...);

intersect(F, Head, Tail...);

<

HeadTy,

SecondTy,

... RestTy>

[[nodiscard]]

IntersectionTraits<HeadTy, SecondTy, RestTy...>

intersect(F, *Head, Second, Tail...);

intersect(F, Second, Tail...);

SymbolicRangeInferrer

<

SourceType>

SourceType Origin) {

SymbolicRangeInferrer Inferrer(F, State);

Inferrer.infer(Origin);

(std::optional<RangeSet> RS = getRangeForNegatedSym(Sym))

infer(Sym->

());

(std::optional<RangeSet> RS = getRangeForNegatedUnarySym(USE))

infer(USE->

());

VisitBinaryOperator(Sym);

VisitBinaryOperator(Sym);

getRangeForNegatedSymSym(SSE),

getRangeCommutativeSymSym(SSE),

getRangeForComparisonSymbol(SSE),

getRangeForEqualities(SSE),

VisitBinaryOperator(SSE));

: ValueFactory(F.getValueFactory()), RangeFactory(F), State(S) {}

{RangeFactory, Val};

infer(DestType);

intersect(RangeFactory,

getConstraint(State, Sym),

infer(EquivalenceClass Class) {

(

*AssociatedConstraint = getConstraint(State, Class))

*AssociatedConstraint;

infer(

.getType());

Result(RangeFactory, ValueFactory.getMinValue(

),

ValueFactory.getMaxValue(

));

assumeNonZero(Result,

);

<

BinarySymExprTy>

VisitBinaryOperator(

BinarySymExprTy *Sym) {

ResultType = Sym->getType();

VisitBinaryOperator(inferAs(Sym->getLHS(), ResultType),

inferAs(Sym->getRHS(), ResultType), ResultType);

std::nullopt;

(ValueFactory.Convert(To, Origin.

()),

ValueFactory.Convert(To, Origin.

()));

<BinaryOperator::Opcode Op>

CoarseLHS = fillGaps(LHS);

CoarseRHS = fillGaps(RHS);

ResultType = ValueFactory.getAPSIntType(

);

ConvertedCoarseLHS = convert(CoarseLHS, ResultType);

ConvertedCoarseRHS = convert(CoarseRHS, ResultType);

(!ConvertedCoarseLHS || !ConvertedCoarseRHS) {

VisitBinaryOperator<Op>(*ConvertedCoarseLHS, *ConvertedCoarseRHS,

);

<BinaryOperator::Opcode Op>

RangeType = ValueFactory.getAPSIntType(

);

(ValueFactory.getMinValue(RangeType), Origin.

());

(Origin.

().isMinSignedValue()) {

{ValueFactory.getMinValue(RangeType),

ValueFactory.getMaxValue(RangeType)};

llvm::APSInt AbsMax = std::max(-Origin.

(), Origin.

());

{ValueFactory.getValue(-AbsMax), ValueFactory.getValue(AbsMax)};

IntType = ValueFactory.getAPSIntType(

);

<

ProduceNegatedSymFunc>

std::optional<RangeSet> getRangeForNegatedExpr(ProduceNegatedSymFunc F,

std::nullopt;

(

*NegatedRange = getConstraint(State, NegatedSym))

RangeFactory.negate(*NegatedRange);

std::nullopt;

std::optional<RangeSet> getRangeForNegatedUnarySym(

*USE) {

getRangeForNegatedExpr(

std::optional<RangeSet> getRangeForNegatedSymSym(

*SSE) {

getRangeForNegatedExpr(

[SSE, State = this->State]() ->

{

State->getSymbolManager().acquire<

>(

std::optional<RangeSet> getRangeForNegatedSym(

Sym) {

getRangeForNegatedExpr(

[Sym, State = this->State]() {

State->getSymbolManager().acquire<UnarySymExpr>(

Sym, UO_Minus, Sym->

());

std::optional<RangeSet> getRangeCommutativeSymSym(

*SSE) {

IsCommutative = llvm::is_contained(

{BO_EQ, BO_NE, BO_Or, BO_And, BO_Add, BO_Mul, BO_Xor}, Op);

std::nullopt;

(

*

= getConstraint(State, Commuted))

std::nullopt;

std::optional<RangeSet> getRangeForComparisonSymbol(

*SSE) {

std::nullopt;

(

i = 0; i < CmpOpTable.getCmpOpCount(); ++i) {

*QueriedRangeSet = getConstraint(State, SymSym);

(!QueriedRangeSet) {

QueriedRangeSet = getConstraint(State, SymSym);

(!QueriedRangeSet || QueriedRangeSet->isEmpty())

llvm::APSInt *ConcreteValue = QueriedRangeSet->getConcreteValue();

isInFalseBranch =

ConcreteValue ? (*ConcreteValue == 0) :

;

(isInFalseBranch)

CmpOpTable.getCmpOpState(CurrentOP, QueriedOP);

(LastQueriedOpToUnknown != CurrentOP &&

LastQueriedOpToUnknown != QueriedOP) {

BranchState = CmpOpTable.getCmpOpStateForUnknownX2(CurrentOP);

LastQueriedOpToUnknown = QueriedOP;

: getFalseRange(

);

std::nullopt;

std::optional<RangeSet> getRangeForEqualities(

*Sym) {

std::optional<bool>

= meansEquality(Sym);

std::nullopt;

(std::optional<bool> AreEqual =

EquivalenceClass::areEqual(State, Sym->

(), Sym->

())) {

(*AreEqual == *Equality) {

getTrueRange(Sym->

());

getFalseRange(Sym->

());

std::nullopt;

assumeNonZero(TypeRange,

);

llvm::APSInt &

= ValueFactory.getValue(0,

);

(RangeFactory, Zero);

(intersect(RangeFactory, LHS, RHS).isEmpty())

getTrueRange(

);

getTrueRange(

);

getTrueRange(

);

CastedLHS = RangeFactory.castTo(LHS, CastingType);

CastedRHS = RangeFactory.castTo(RHS, CastingType);

(intersect(RangeFactory, CastedLHS, CastedRHS).isEmpty())

getTrueRange(

);

ResultType = ValueFactory.getAPSIntType(

);

IsLHSPositiveOrZero = LHS.

() >=

;

IsRHSPositiveOrZero = RHS.

() >=

;

IsLHSNegative = LHS.

() <

;

IsRHSNegative = RHS.

() <

;

((IsLHSPositiveOrZero && IsRHSPositiveOrZero) ||

(IsLHSNegative && IsRHSNegative)) {

llvm::APSInt &

= std::max(LHS.

(), RHS.

());

llvm::APSInt &

= IsLHSNegative

? ValueFactory.getValue(--Zero)

: ValueFactory.getMaxValue(ResultType);

{RangeFactory, ValueFactory.getValue(

),

};

(IsLHSNegative || IsRHSNegative) {

{RangeFactory, ValueFactory.getMinValue(ResultType),

ValueFactory.getValue(--Zero)};

assumeNonZero(DefaultRange,

);

DefaultRange;

SymbolicRangeInferrer::VisitBinaryOperator<BO_And>(

LHS,

ResultType = ValueFactory.getAPSIntType(

);

IsLHSPositiveOrZero = LHS.

() >=

;

IsRHSPositiveOrZero = RHS.

() >=

;

IsLHSNegative = LHS.

() <

;

IsRHSNegative = RHS.

() <

;

((IsLHSPositiveOrZero && IsRHSPositiveOrZero) ||

(IsLHSNegative && IsRHSNegative)) {

llvm::APSInt &

= std::min(LHS.

(), RHS.

());

llvm::APSInt &

= IsLHSNegative

? ValueFactory.getMinValue(ResultType)

: ValueFactory.getValue(Zero);

{RangeFactory,

,

};

(IsLHSPositiveOrZero || IsRHSPositiveOrZero) {

llvm::APSInt &

= IsLHSPositiveOrZero ? LHS.

() : RHS.

();

{RangeFactory, ValueFactory.getValue(Zero),

ValueFactory.getValue(

)};

SymbolicRangeInferrer::VisitBinaryOperator<BO_Rem>(

LHS,

llvm::APSInt

= ValueFactory.getAPSIntType(

).getZeroValue();

ConservativeRange = getSymmetricalRange(RHS,

);

llvm::APSInt

= ConservativeRange.

();

llvm::APSInt

= ConservativeRange.

();

RangeFactory.getEmptySet();

(

.isSigned()) {

IsLHSPositiveOrZero = LHS.

() >=

;

IsRHSPositiveOrZero = RHS.

() >=

;

(IsLHSPositiveOrZero && IsRHSPositiveOrZero) {

{RangeFactory, ValueFactory.getValue(

), ValueFactory.getValue(

)};

RangeFactory.getEmptySet();

VisitBinaryOperator<BO_NE>(LHS, RHS,

);

VisitBinaryOperator<BO_Or>(LHS, RHS,

);

VisitBinaryOperator<BO_And>(LHS, RHS,

);

VisitBinaryOperator<BO_Rem>(LHS, RHS,

);

S1->get<ConstraintRange>() == S2->get<ConstraintRange>() &&

S1->get<ClassMap>() == S2->get<ClassMap>();

canReasonAbout(

)

;

printJson(raw_ostream &Out,

State,

*NL =

,

Space = 0,

IsDot =

)

;

*NL =

,

Space = 0,

IsDot =

)

;

*NL =

,

Space = 0,

IsDot =

)

;

*NL =

,

Space = 0,

IsDot =

)

;

llvm::APSInt &

,

llvm::APSInt &Adjustment)

;

llvm::APSInt &

,

llvm::APSInt &Adjustment)

;

llvm::APSInt &

,

llvm::APSInt &Adjustment)

;

llvm::APSInt &

,

llvm::APSInt &Adjustment)

;

llvm::APSInt &

,

llvm::APSInt &Adjustment)

;

llvm::APSInt &

,

llvm::APSInt &Adjustment)

;

llvm::APSInt &To,

llvm::APSInt &Adjustment)

;

llvm::APSInt &To,

llvm::APSInt &Adjustment)

;

llvm::APSInt &Int,

llvm::APSInt &Adjustment)

;

llvm::APSInt &Int,

llvm::APSInt &Adjustment)

;

llvm::APSInt &Int,

llvm::APSInt &Adjustment)

;

llvm::APSInt &Int,

llvm::APSInt &Adjustment)

;

llvm::APSInt &Int,

llvm::APSInt &Adjustment)

;

<

Derived>

ConstraintAssignorBase {

=

llvm::APSInt &;

assignImpl(Sym, Constraint);

llvm_unreachable(

);

ConstraintAssignor :

ConstraintAssignorBase<ConstraintAssignor> {

<

ClassOrSymbol>

ClassOrSymbol CoS,

NewConstraint) {

(!State || NewConstraint.

())

ConstraintAssignor Assignor{State, Builder, F};

Assignor.assign(CoS, NewConstraint);

<

SymT>

handleRemainderOp(

SymT *Sym,

Constraint) {

(Sym->getOpcode() != BO_Rem)

SymSVal = Builder.makeSymbolVal(Sym->getLHS());

State = State->assume(*NonLocSymSVal,

);

assignSymExprToConst(

*Sym, Const Constraint);

assignSymIntExprToRangeSet(

*Sym,

handleRemainderOp(Sym, Constraint);

assignSymSymExprToRangeSet(

*Sym,

: State(State), Builder(Builder), RangeFactory(F) {}

= ConstraintAssignorBase<ConstraintAssignor>;

State = assign(EquivalenceClass::find(State, Sym), NewConstraint);

Base::assign(Sym, NewConstraint);

ConstraintRangeTy Constraints = State->get<ConstraintRange>();

ConstraintRangeTy::Factory &

= State->get_context<ConstraintRange>();

Constraints =

.add(Constraints, Class, NewConstraint);

(EquivalenceClass DisequalClass :

.getDisequalClasses(State)) {

UpdatedConstraint = SymbolicRangeInferrer::inferRange(

RangeFactory, State, DisequalClass);

UpdatedConstraint = RangeFactory.deletePoint(UpdatedConstraint, *Point);

(UpdatedConstraint.

())

Constraints =

.add(Constraints, DisequalClass, UpdatedConstraint);

assert(areFeasible(Constraints) &&

);

setConstraints(State, Constraints);

setConstraint(State, Class, NewConstraint);

EquivalenceClass::markDisequal(RangeFactory, State, LHS, RHS);

EquivalenceClass::merge(RangeFactory, State, LHS, RHS);

[[nodiscard]] std::optional<bool> interpreteAsBool(

Constraint) {

assert(!Constraint.

() &&

);

std::nullopt;

ConstraintAssignor::assignSymExprToConst(

*Sym,

llvm::APSInt &Constraint) {

llvm::SmallSet<EquivalenceClass, 4> SimplifiedClasses;

ClassMembersTy Members = State->get<ClassMembers>();

(std::pair<EquivalenceClass, SymbolSet> ClassToSymbolSet : Members) {

EquivalenceClass

= ClassToSymbolSet.first;

State = EquivalenceClass::simplify(Builder, RangeFactory, State, Class);

SimplifiedClasses.insert(Class);

ConstraintRangeTy Constraints = State->get<ConstraintRange>();

(std::pair<EquivalenceClass, RangeSet> ClassConstraint : Constraints) {

EquivalenceClass

= ClassConstraint.first;

(SimplifiedClasses.count(Class))

State = EquivalenceClass::simplify(Builder, RangeFactory, State, Class);

DisequalityMapTy DisequalityInfo = State->get<DisequalityMap>();

(std::pair<EquivalenceClass, ClassSet> DisequalityEntry :

EquivalenceClass

= DisequalityEntry.first;

ClassSet DisequalClasses = DisequalityEntry.second;

State = EquivalenceClass::simplify(Builder, RangeFactory, State, Class);

ConstraintAssignor::assignSymSymExprToRangeSet(

*Sym,

(!handleRemainderOp(Sym, Constraint))

std::optional<bool> ConstraintAsBool = interpreteAsBool(Constraint);

(!ConstraintAsBool)

(std::optional<bool> Equality = meansEquality(Sym)) {

(*Equality == *ConstraintAsBool) {

State = trackEquality(State, Sym->

(), Sym->

());

State = trackDisequality(State, Sym->

(), Sym->

());

std::unique_ptr<ConstraintManager>

std::make_unique<RangeConstraintManager>(Eng, StMgr.

());

ConstraintMap::Factory &F = State->get_context<

>();

ConstraintRangeTy Constraints = State->get<ConstraintRange>();

(std::pair<EquivalenceClass, RangeSet> ClassConstraint : Constraints) {

EquivalenceClass

= ClassConstraint.first;

assert(!ClassMembers.isEmpty() &&

);

Representative = *ClassMembers.begin();

= F.add(

, Representative, ClassConstraint.second);

LLVM_DUMP_METHOD

EquivalenceClass::dumpToStream(

State,

raw_ostream &os)

{

ClassMembers = getClassMembers(State);

(

&MemberSym : ClassMembers) {

assert(State &&

);

assert(Sym &&

);

(

EquivalenceClass *NontrivialClass = State->get<ClassMap>(Sym))

*NontrivialClass;

EquivalenceClass FirstClass = find(State,

);

EquivalenceClass SecondClass = find(State, Second);

FirstClass.merge(F, State, SecondClass);

EquivalenceClass

) {

(*

==

)

(getType()->getCanonicalTypeUnqualified() !=

.getType()->getCanonicalTypeUnqualified())

Members = getClassMembers(State);

(Members.getHeight() >= OtherMembers.getHeight()) {

mergeImpl(F, State, Members,

, OtherMembers);

.mergeImpl(F, State, OtherMembers, *

, Members);

ConstraintRangeTy Constraints = State->get<ConstraintRange>();

ConstraintRangeTy::Factory &CRF = State->get_context<ConstraintRange>();

(std::optional<RangeSet> NewClassConstraint =

intersect(RangeFactory, getConstraint(State, *

),

getConstraint(State,

))) {

(NewClassConstraint->isEmpty())

Constraints = CRF.remove(Constraints,

);

Constraints = CRF.add(Constraints, *

, *NewClassConstraint);

assert(areFeasible(Constraints) &&

);

State = State->set<ConstraintRange>(Constraints);

ClassMapTy Classes = State->get<ClassMap>();

ClassMapTy::Factory &CMF = State->get_context<ClassMap>();

ClassMembersTy Members = State->get<ClassMembers>();

ClassMembersTy::Factory &MF = State->get_context<ClassMembers>();

DisequalityMapTy DisequalityInfo = State->get<DisequalityMap>();

DisequalityMapTy::Factory &DF = State->get_context<DisequalityMap>();

ClassSet::Factory &

= State->get_context<ClassSet>();

SymbolSet::Factory &F = getMembersFactory(State);

NewClassMembers = F.add(NewClassMembers, Sym);

Classes = CMF.add(Classes, Sym, *

);

Members = MF.remove(Members,

);

Members = MF.add(Members, *

, NewClassMembers);

ClassSet DisequalToOther =

.getDisequalClasses(DisequalityInfo,

);

(DisequalToOther.contains(*

))

(!DisequalToOther.isEmpty()) {

ClassSet DisequalToThis = getDisequalClasses(DisequalityInfo,

);

DisequalityInfo = DF.remove(DisequalityInfo,

);

(EquivalenceClass DisequalClass : DisequalToOther) {

DisequalToThis =

.add(DisequalToThis, DisequalClass);

ClassSet OriginalSetLinkedToOther =

*DisequalityInfo.lookup(DisequalClass);

ClassSet NewSet =

.remove(OriginalSetLinkedToOther,

);

NewSet =

.add(NewSet, *

);

DisequalityInfo = DF.add(DisequalityInfo, DisequalClass, NewSet);

DisequalityInfo = DF.add(DisequalityInfo, *

, DisequalToThis);

State = State->set<DisequalityMap>(DisequalityInfo);

State = State->set<ClassMap>(Classes);

State = State->set<ClassMembers>(Members);

SymbolSet::Factory &

State->get_context<

>();

(

*Members = State->get<ClassMembers>(*

))

SymbolSet::Factory &F = getMembersFactory(State);

F.add(F.getEmptySet(), getRepresentativeSymbol());

State->get<ClassMembers>(*this) ==

;

(State) && Reaper.

(getRepresentativeSymbol());

markDisequal(RF, State, find(State,

), find(State, Second));

EquivalenceClass

,

EquivalenceClass Second) {

.markDisequal(RF, State, Second);

EquivalenceClass

)

{

(*

==

) {

DisequalityMapTy DisequalityInfo = State->get<DisequalityMap>();

ConstraintRangeTy Constraints = State->get<ConstraintRange>();

(!addToDisequalityInfo(DisequalityInfo, Constraints, RF, State, *

,

!addToDisequalityInfo(DisequalityInfo, Constraints, RF, State,

,

assert(areFeasible(Constraints) &&

);

State = State->set<DisequalityMap>(DisequalityInfo);

State = State->set<ConstraintRange>(Constraints);

EquivalenceClass::addToDisequalityInfo(

DisequalityMapTy &Info, ConstraintRangeTy &Constraints,

EquivalenceClass Second) {

DisequalityMapTy::Factory &F = State->get_context<DisequalityMap>();

ClassSet::Factory &

= State->get_context<ClassSet>();

ConstraintRangeTy::Factory &CRF = State->get_context<ConstraintRange>();

ClassSet *CurrentSet = Info.lookup(

);

ClassSet NewSet = CurrentSet ? *CurrentSet :

.getEmptySet();

NewSet =

.add(NewSet, Second);

Info = F.add(Info,

, NewSet);

(

*SecondConstraint = Constraints.lookup(Second))

(

llvm::APSInt *Point = SecondConstraint->getConcreteValue()) {

FirstConstraint = SymbolicRangeInferrer::inferRange(

RF, State,

.getRepresentativeSymbol());

FirstConstraint = RF.

(FirstConstraint, *Point);

(FirstConstraint.

())

Constraints = CRF.add(Constraints,

, FirstConstraint);

std::optional<bool> EquivalenceClass::areEqual(

State,

EquivalenceClass::areEqual(State, find(State, FirstSym),

find(State, SecondSym));

std::optional<bool> EquivalenceClass::areEqual(

State,

EquivalenceClass

,

EquivalenceClass Second) {

(

== Second)

ClassSet DisequalToFirst =

.getDisequalClasses(State);

(DisequalToFirst.contains(Second))

std::nullopt;

ClsMembers = getClassMembers(State);

assert(ClsMembers.contains(Old));

SymbolSet::Factory &F = getMembersFactory(State);

ClassMembersTy::Factory &EMFactory = State->get_context<ClassMembers>();

ClsMembers = F.remove(ClsMembers, Old);

assert(!ClsMembers.isEmpty() &&

);

ClassMembersTy ClassMembersMap = State->get<ClassMembers>();

ClassMembersMap = EMFactory.add(ClassMembersMap, *

, ClsMembers);

State = State->set<ClassMembers>(ClassMembersMap);

ClassMapTy Classes = State->get<ClassMap>();

ClassMapTy::Factory &CMF = State->get_context<ClassMap>();

Classes = CMF.remove(Classes, Old);

State = State->set<ClassMap>(Classes);

State->assume(DefinedVal,

);

State = State->assume(DefinedVal,

);

State->assumeInclusiveRange(DefinedVal, Constraint->

(),

(

&MemberSym : ClassMembers) {

llvm::APSInt &SV = CI->getValue();

*ClassConstraint = getConstraint(State,

);

(ClassConstraint && !ClassConstraint->

(SV))

(SimplifiedMemberSym && MemberSym != SimplifiedMemberSym) {

State = merge(F, State, MemberSym, SimplifiedMemberSym);

(OldState == State)

State = find(State, MemberSym).removeMember(State, MemberSym);

*ClassConstraint = getConstraint(State,

);

State =

(State, ClassConstraint, SimplifiedMemberVal);

ClassSet EquivalenceClass::getDisequalClasses(

State,

find(State, Sym).getDisequalClasses(State);

getDisequalClasses(State->get<DisequalityMap>(),

State->get_context<ClassSet>());

EquivalenceClass::getDisequalClasses(DisequalityMapTy Map,

ClassSet::Factory &Factory)

{

(

ClassSet *DisequalClasses = Map.lookup(*

))

*DisequalClasses;

Factory.getEmptySet();

ClassMembersTy Members = State->get<ClassMembers>();

(std::pair<EquivalenceClass, SymbolSet> ClassMembersPair : Members) {

(find(State,

) == ClassMembersPair.first) {

DisequalityMapTy Disequalities = State->get<DisequalityMap>();

(std::pair<EquivalenceClass, ClassSet> DisequalityInfo : Disequalities) {

EquivalenceClass

= DisequalityInfo.first;

ClassSet DisequalClasses = DisequalityInfo.second;

(DisequalClasses.isEmpty())

(EquivalenceClass DisequalClass : DisequalClasses) {

ClassSet *DisequalToDisequalClasses =

Disequalities.lookup(DisequalClass);

(!DisequalToDisequalClasses ||

!DisequalToDisequalClasses->contains(

))

RangeConstraintManager::canReasonAbout(

)

{

(SymVal && SymVal->isExpression()) {

*SE = SymVal->getSymbol();

(

*SIE = dyn_cast<SymIntExpr>(SE)) {

(SIE->getOpcode()) {

(

*SSE = dyn_cast<SymSymExpr>(SE)) {

*Ranges = getConstraint(State, Sym);

*

== 0;

llvm::APSInt *RangeConstraintManager::getSymVal(

St,

(St, Sym).getConcreteValue();

llvm::APSInt *RangeConstraintManager::getSymMinVal(

St,

.isEmpty() ? nullptr : &

.getMinValue();

llvm::APSInt *RangeConstraintManager::getSymMaxVal(

St,

.isEmpty() ? nullptr : &

.getMaxValue();

ClassMembersTy ClassMembersMap = State->get<ClassMembers>();

ClassMembersTy NewClassMembersMap = ClassMembersMap;

ClassMembersTy::Factory &EMFactory = State->get_context<ClassMembers>();

SymbolSet::Factory &SetFactory = State->get_context<

>();

ConstraintRangeTy Constraints = State->get<ConstraintRange>();

ConstraintRangeTy NewConstraints = Constraints;

ConstraintRangeTy::Factory &ConstraintFactory =

State->get_context<ConstraintRange>();

ClassMapTy Map = State->get<ClassMap>();

ClassMapTy NewMap = Map;

ClassMapTy::Factory &ClassFactory = State->get_context<ClassMap>();

DisequalityMapTy Disequalities = State->get<DisequalityMap>();

DisequalityMapTy::Factory &DisequalityFactory =

State->get_context<DisequalityMap>();

ClassSet::Factory &ClassSetFactory = State->get_context<ClassSet>();

ClassMapChanged =

;

MembersMapChanged =

;

ConstraintMapChanged =

;

DisequalitiesChanged =

;

removeDeadClass = [&](EquivalenceClass

) {

Constraints = ConstraintFactory.remove(Constraints,

);

ConstraintMapChanged =

;

ClassSet DisequalClasses =

.getDisequalClasses(Disequalities, ClassSetFactory);

(!DisequalClasses.isEmpty()) {

(EquivalenceClass DisequalClass : DisequalClasses) {

ClassSet DisequalToDisequalSet =

DisequalClass.getDisequalClasses(Disequalities, ClassSetFactory);

assert(!DisequalToDisequalSet.isEmpty());

ClassSet NewSet = ClassSetFactory.remove(DisequalToDisequalSet,

);

(NewSet.isEmpty()) {

DisequalityFactory.remove(Disequalities, DisequalClass);

DisequalityFactory.add(Disequalities, DisequalClass, NewSet);

Disequalities = DisequalityFactory.remove(Disequalities,

);

DisequalitiesChanged =

;

(std::pair<EquivalenceClass, RangeSet> ClassConstraintPair :

EquivalenceClass

= ClassConstraintPair.first;

(

.isTriviallyDead(State, SymReaper)) {

removeDeadClass(

);

(std::pair<SymbolRef, EquivalenceClass> SymbolClassPair : Map) {

(SymReaper.

(Sym)) {

ClassMapChanged =

;

NewMap = ClassFactory.remove(NewMap, Sym);

(std::pair<EquivalenceClass, SymbolSet> ClassMembersPair :

EquivalenceClass

= ClassMembersPair.first;

LiveMembers = ClassMembersPair.second;

MembersChanged =

;

MembersChanged =

;

LiveMembers = SetFactory.remove(LiveMembers,

);

(!MembersChanged)

MembersMapChanged =

;

(LiveMembers.isEmpty()) {

NewClassMembersMap = EMFactory.remove(NewClassMembersMap,

);

removeDeadClass(

);

NewClassMembersMap =

EMFactory.add(NewClassMembersMap,

, LiveMembers);

(ClassMapChanged)

State = State->set<ClassMap>(NewMap);

(MembersMapChanged)

State = State->set<ClassMembers>(NewClassMembersMap);

(ConstraintMapChanged)

State = State->set<ConstraintRange>(Constraints);

(DisequalitiesChanged)

State = State->set<DisequalityMap>(Disequalities);

assert(EquivalenceClass::isClassDataConsistent(State));

SymbolicRangeInferrer::inferRange(F, State, Sym);

ConstraintAssignor::assign(State, getSValBuilder(), F, Sym,

);

llvm::APSInt &Int,

llvm::APSInt &Adjustment) {

llvm::APSInt Point = AdjustmentType.convert(Int) - Adjustment;

setRange(St, Sym, New);

llvm::APSInt &Int,

llvm::APSInt &Adjustment) {

llvm::APSInt AdjInt = AdjustmentType.convert(Int) - Adjustment;

setRange(St, Sym, New);

llvm::APSInt &Int,

llvm::APSInt &Adjustment)

{

(AdjustmentType.testInRange(Int,

)) {

llvm::APSInt ComparisonVal = AdjustmentType.convert(Int);

llvm::APSInt

= AdjustmentType.getMinValue();

(ComparisonVal ==

)

llvm::APSInt Lower =

- Adjustment;

llvm::APSInt Upper = ComparisonVal - Adjustment;

llvm::APSInt &Int,

llvm::APSInt &Adjustment) {

New = getSymLTRange(St, Sym, Int, Adjustment);

setRange(St, Sym, New);

llvm::APSInt &Int,

llvm::APSInt &Adjustment)

{

(AdjustmentType.testInRange(Int,

)) {

llvm::APSInt ComparisonVal = AdjustmentType.convert(Int);

llvm::APSInt

= AdjustmentType.getMaxValue();

(ComparisonVal ==

)

llvm::APSInt Lower = ComparisonVal - Adjustment;

llvm::APSInt Upper =

- Adjustment;

F.

(SymRange, Lower, Upper);

llvm::APSInt &Int,

llvm::APSInt &Adjustment) {

New = getSymGTRange(St, Sym, Int, Adjustment);

setRange(St, Sym, New);

llvm::APSInt &Int,

llvm::APSInt &Adjustment)

{

(AdjustmentType.testInRange(Int,

)) {

llvm::APSInt ComparisonVal = AdjustmentType.convert(Int);

llvm::APSInt

= AdjustmentType.getMinValue();

(ComparisonVal ==

)

llvm::APSInt

= AdjustmentType.getMaxValue();

llvm::APSInt Lower = ComparisonVal - Adjustment;

llvm::APSInt Upper =

- Adjustment;

F.

(SymRange, Lower, Upper);

llvm::APSInt &Int,

llvm::APSInt &Adjustment) {

New = getSymGERange(St, Sym, Int, Adjustment);

setRange(St, Sym, New);

RangeConstraintManager::getSymLERange(llvm::function_ref<

()> RS,

llvm::APSInt &Int,

llvm::APSInt &Adjustment)

{

(AdjustmentType.testInRange(Int,

)) {

llvm::APSInt ComparisonVal = AdjustmentType.convert(Int);

llvm::APSInt

= AdjustmentType.getMaxValue();

(ComparisonVal ==

)

llvm::APSInt

= AdjustmentType.getMinValue();

llvm::APSInt Lower =

- Adjustment;

llvm::APSInt Upper = ComparisonVal - Adjustment;

llvm::APSInt &Int,

llvm::APSInt &Adjustment)

{

getSymLERange([&] {

(St, Sym); },

, Adjustment);

llvm::APSInt &Int,

llvm::APSInt &Adjustment) {

New = getSymLERange(St, Sym, Int, Adjustment);

setRange(St, Sym, New);

llvm::APSInt &To,

llvm::APSInt &Adjustment) {

New = getSymGERange(State, Sym, From, Adjustment);

Out = getSymLERange([&] {

New; }, To, Adjustment);

setRange(State, Sym, Out);

RangeConstraintManager::assumeSymOutsideInclusiveRange(

llvm::APSInt &To,

llvm::APSInt &Adjustment) {

RangeLT = getSymLTRange(State, Sym, From, Adjustment);

RangeGT = getSymGTRange(State, Sym, To, Adjustment);

setRange(State, Sym, New);

RangeConstraintManager::printJson(raw_ostream &Out,

State,

*NL,

Space,

printConstraints(Out, State, NL, Space, IsDot);

printEquivalenceClasses(Out, State, NL, Space, IsDot);

printDisequalities(Out, State, NL, Space, IsDot);

RangeConstraintManager::printValue(raw_ostream &Out,

State,

Out <<

;

llvm::raw_string_ostream O(S);

RangeConstraintManager::printConstraints(raw_ostream &Out,

ConstraintRangeTy Constraints = State->get<ConstraintRange>();

Indent(Out, Space, IsDot) <<

;

(Constraints.isEmpty()) {

Out <<

<< NL;

std::map<std::string, RangeSet> OrderedConstraints;

(std::pair<EquivalenceClass, RangeSet>

: Constraints) {

ClassMembers =

.first.getClassMembers(State);

(

&ClassMember : ClassMembers) {

insertion_took_place;

std::tie(std::ignore, insertion_took_place) =

OrderedConstraints.insert({

(ClassMember),

.second});

assert(insertion_took_place &&

);

(std::pair<std::string, RangeSet>

: OrderedConstraints) {

Indent(Out, Space, IsDot)

<<

<<

.first <<

;

.second.dump(Out);

Indent(Out, Space, IsDot) <<

<< NL;

ClassMembers.end());

llvm::sort(ClassMembersSorted,

FirstMember =

;

llvm::raw_string_ostream Out(Str);

(

ClassMember : ClassMembersSorted) {

FirstMember =

;

Out <<

<< ClassMember <<

;

RangeConstraintManager::printEquivalenceClasses(raw_ostream &Out,

ClassMembersTy Members = State->get<ClassMembers>();

Indent(Out, Space, IsDot) <<

;

(Members.isEmpty()) {

Out <<

<< NL;

std::set<std::string> MembersStr;

(std::pair<EquivalenceClass, SymbolSet> ClassToSymbolSet : Members)

MembersStr.insert(

(State, ClassToSymbolSet.first));

FirstClass =

;

(

std::string &Str : MembersStr) {

FirstClass =

;

Indent(Out, Space, IsDot);

Indent(Out, Space, IsDot) <<

<< NL;

RangeConstraintManager::printDisequalities(raw_ostream &Out,

DisequalityMapTy Disequalities = State->get<DisequalityMap>();

Indent(Out, Space, IsDot) <<

;

(Disequalities.isEmpty()) {

Out <<

<< NL;

EqClassesStrTy = std::set<std::string>;

DisequalityInfoStrTy = std::map<std::string, EqClassesStrTy>;

DisequalityInfoStrTy DisequalityInfoStr;

(std::pair<EquivalenceClass, ClassSet> ClassToDisEqSet : Disequalities) {

EquivalenceClass

= ClassToDisEqSet.first;

ClassSet DisequalClasses = ClassToDisEqSet.second;

EqClassesStrTy MembersStr;

(EquivalenceClass DisEqClass : DisequalClasses)

MembersStr.insert(

(State, DisEqClass));

DisequalityInfoStr.insert({

(State,

), MembersStr});

FirstClass =

;

(std::pair<std::string, EqClassesStrTy> ClassToDisEqSet :

DisequalityInfoStr) {

std::string &

= ClassToDisEqSet.first;

FirstClass =

;

Indent(Out, Space, IsDot) <<

<< NL;

DisEqSpace = Space + 1;

Indent(Out, DisEqSpace, IsDot) <<

;

EqClassesStrTy &DisequalClasses = ClassToDisEqSet.second;

(!DisequalClasses.empty()) {

Indent(Out, DisEqSpace, IsDot) <<

<< NL;

DisEqClassSpace = DisEqSpace + 1;

Indent(Out, DisEqClassSpace, IsDot);

FirstDisEqClass =

;

(

std::string &DisEqClass : DisequalClasses) {

(FirstDisEqClass) {

FirstDisEqClass =

;

Indent(Out, DisEqClassSpace, IsDot);

Indent(Out, Space, IsDot) <<

;

Indent(Out, Space, IsDot) <<

<< NL;

static bool isTrivial(ASTContext &Ctx, const Expr *E)

Checks if the expression is constant or does not have non-trivial function calls.

static void dump(llvm::raw_ostream &OS, StringRef FunctionName, ArrayRef< CounterExpression > Expressions, ArrayRef< CounterMappingRegion > Regions)

llvm::MachO::SymbolSet SymbolSet

#define REGISTER_MAP_WITH_PROGRAMSTATE(Name, Key, Value)

Declares an immutable map of type NameTy, suitable for placement into the ProgramState.

#define REGISTER_SET_FACTORY_WITH_PROGRAMSTATE(Name, Elem)

Declares an immutable set type Name and registers the factory for such sets in the program state,...

#define CONSTRAINT_DISPATCH(Id)

static void swapIterators(T &First, T &FirstEnd, T &Second, T &SecondEnd)

static ProgramStateRef reAssume(ProgramStateRef State, const RangeSet *Constraint, SVal TheValue)

#define DEFAULT_ASSIGN(Id)

static std::string toString(const clang::SanitizerSet &Sanitizers)

Produce a string containing comma-separated names of sanitizers in Sanitizers set.

static CharSourceRange getRange(const CharSourceRange &EditRange, const SourceManager &SM, const LangOptions &LangOpts, bool IncludeMacroExpansion)

static BinaryOperatorKind getOpFromIndex(size_t Index)

constexpr size_t getCmpOpCount() const

TriStateKind getCmpOpState(BinaryOperatorKind CurrentOP, BinaryOperatorKind QueriedOP) const

TriStateKind getCmpOpStateForUnknownX2(BinaryOperatorKind CurrentOP) const

bool isComparisonOp() const

bool isRelationalOp() const

static Opcode negateComparisonOp(Opcode Opc)

static Opcode reverseComparisonOp(Opcode Opc)

bool isEqualityOp() const

A (possibly-)qualified type.

The base class of the type hierarchy.

bool isSignedIntegerOrEnumerationType() const

Determines whether this is an integer type that is signed or an enumeration types whose underlying ty...

bool isUnsignedIntegerOrEnumerationType() const

Determines whether this is an integer type that is unsigned or an enumeration types whose underlying ...

bool isReferenceType() const

bool isIntegralOrEnumerationType() const

Determine whether this type is an integral or enumeration type.

A record of the "type" of an APSInt, used for conversions.

llvm::APSInt getZeroValue() const LLVM_READONLY

Returns an all-zero value for this type.

RangeTestResultKind

Used to classify whether a value is representable using this type.

@ RTR_Within

Value is representable using this type.

@ RTR_Below

Value is less than the minimum representable value.

@ RTR_Above

Value is greater than the maximum representable value.

uint32_t getBitWidth() const

RangeTestResultKind testInRange(const llvm::APSInt &Val, bool AllowMixedSign) const LLVM_READONLY

Tests whether a given value is losslessly representable using this type.

void apply(llvm::APSInt &Value) const

Convert a given APSInt, in place, to match this type.

llvm::APSInt getMinValue() const LLVM_READONLY

Returns the minimum value for this type.

llvm::APSInt convert(const llvm::APSInt &Value) const LLVM_READONLY

Convert and return a new APSInt with the given value, but this type's bit width and signedness.

llvm::APSInt getValue(uint64_t RawValue) const LLVM_READONLY

APSIntType getAPSIntType(QualType T) const

Returns the type of the APSInt used to store values of the given QualType.

Template implementation for all binary symbolic expressions.

QualType getType() const override

BinaryOperator::Opcode getOpcode() const

static bool isLocType(QualType T)

SValBuilder & getSValBuilder()

RangeSet unite(RangeSet LHS, RangeSet RHS)

Create a new set which is a union of two given ranges.

RangeSet negate(RangeSet What)

Negate the given range set.

RangeSet intersect(RangeSet LHS, RangeSet RHS)

Intersect the given range sets.

RangeSet deletePoint(RangeSet From, const llvm::APSInt &Point)

Delete the given point from the range set.

RangeSet getRangeSet(Range Origin)

Create a new set with just one range.

RangeSet add(RangeSet LHS, RangeSet RHS)

Create a new set with all ranges from both LHS and RHS.

RangeSet castTo(RangeSet What, APSIntType Ty)

Performs promotions, truncations and conversions of the given set.

persistent set of non-overlapping ranges.

const_iterator end() const

APSIntType getAPSIntType() const

const llvm::APSInt & getMaxValue() const

Get the maximal value covered by the ranges in the set.

bool encodesTrueRange() const

Test if the range doesn't contain zero.

bool encodesFalseRange() const

Test if the range is the [0,0] range.

const_iterator begin() const

const llvm::APSInt & getMinValue() const

Get the minimal value covered by the ranges in the set.

ImplType::const_iterator const_iterator

bool contains(llvm::APSInt Point) const

Test whether the given point is contained by any of the ranges.

void dump(raw_ostream &OS) const

bool containsZero() const

uint32_t getBitWidth() const

const llvm::APSInt * getConcreteValue() const

getConcreteValue - If a symbol is constrained to equal a specific integer constant then this method r...

A Range represents the closed range [from, to].

const llvm::APSInt & From() const

void dump(raw_ostream &OS) const

bool Includes(const llvm::APSInt &Point) const

const llvm::APSInt & To() const

SVal - This represents a symbolic expression, which can be either an L-value or an R-value.

SymbolRef getAsSymbol(bool IncludeBaseRegions=false) const

If this SVal wraps a symbol return that SymbolRef.

std::optional< T > getAs() const

Convert to the specified SVal type, returning std::nullopt if this SVal is not of the desired type.

T castAs() const

Convert to the specified SVal type, asserting that this SVal is of the desired type.

SymExprVisitor - this class implements a simple visitor for SymExpr subclasses.

virtual void dumpToStream(raw_ostream &os) const

virtual QualType getType() const =0

const SymExprT * acquire(Args &&...args)

Create or retrieve a SymExpr of type SymExprT for the given arguments.

A class responsible for cleaning up unused symbols.

bool isDead(SymbolRef sym)

Returns whether or not a symbol has been confirmed dead.

Represents a symbolic expression involving a unary operator.

QualType getType() const override

UnaryOperator::Opcode getOpcode() const

const SymExpr * getOperand() const

Value representing integer constant.

Represents symbolic expression that isn't a location.

SVal simplifyToSVal(ProgramStateRef State, SymbolRef Sym)

Try to simplify a given symbolic expression's associated SVal based on the constraints in State.

llvm::ImmutableMap< SymbolRef, RangeSet > ConstraintMap

SymbolRef simplify(ProgramStateRef State, SymbolRef Sym)

Try to simplify a given symbolic expression based on the constraints in State.

@ OS

Indicates that the tracking object is a descendant of a referenced-counted OSObject,...

@ CF

Indicates that the tracked object is a CF object.

std::unique_ptr< ConstraintManager > CreateRangeConstraintManager(ProgramStateManager &statemgr, ExprEngine *exprengine)

ConstraintMap getConstraintMap(ProgramStateRef State)

bool Zero(InterpState &S, CodePtr OpPC)

bool Const(InterpState &S, CodePtr OpPC, const T &Arg)

The JSON file list parser is used to communicate input to InstallAPI.

bool operator==(const CallGraphNode::CallRecord &LHS, const CallGraphNode::CallRecord &RHS)

bool operator<(DeclarationName LHS, DeclarationName RHS)

Ordering on two declaration names.

@ Result

The result type of a method or function.

bool operator!=(CanQual< T > x, CanQual< U > y)

const FunctionProtoType * T

@ Class

The "class" keyword introduces the elaborated-type-specifier.

@ Other

Other implicit parameter.

__UINTPTR_TYPE__ uintptr_t

An unsigned integer type with the property that any valid pointer to void can be converted to this ty...

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4