Lines Matching defs:Sym
918 SymbolRef Sym);
959 SymbolRef Sym);
1014 /* implicit */ EquivalenceClass(SymbolRef Sym)
1015 : ID(reinterpret_cast<uintptr_t>(Sym)) {}
1059 SymbolRef Sym) {
1060 return getConstraint(State, EquivalenceClass::find(State, Sym));
1084 /// \returns true if assuming this Sym to be true means equality of operands
1087 std::optional<bool> meansEquality(const SymSymExpr *Sym) {
1088 switch (Sym->getOpcode()) {
1218 RangeSet VisitSymExpr(SymbolRef Sym) {
1219 if (std::optional<RangeSet> RS = getRangeForNegatedSym(Sym))
1225 return infer(Sym->getType());
1234 RangeSet VisitSymIntExpr(const SymIntExpr *Sym) {
1235 return VisitBinaryOperator(Sym);
1238 RangeSet VisitIntSymExpr(const IntSymExpr *Sym) {
1239 return VisitBinaryOperator(Sym);
1245 // If Sym is a difference of symbols A - B, then maybe we have range
1254 // If Sym is a comparison expression (except <=>),
1258 // If Sym is (dis)equality, we might have some information
1278 RangeSet inferAs(SymbolRef Sym, QualType DestType) {
1279 QualType ActualType = Sym->getType();
1283 return infer(Sym);
1290 RangeSet infer(SymbolRef Sym) {
1294 getConstraint(State, Sym),
1295 // Apart from the Sym itself, we can infer quite a lot if
1296 // we look into subexpressions of Sym.
1297 Visit(Sym));
1322 RangeSet VisitBinaryOperator(const BinarySymExprTy *Sym) {
1334 QualType ResultType = Sym->getType();
1335 return VisitBinaryOperator(inferAs(Sym->getLHS(), ResultType),
1336 Sym->getOpcode(),
1337 inferAs(Sym->getRHS(), ResultType), ResultType);
1481 std::optional<RangeSet> getRangeForNegatedSym(SymbolRef Sym) {
1483 [Sym, State = this->State]() {
1485 Sym, UO_Minus, Sym->getType());
1487 Sym->getType());
1594 std::optional<RangeSet> getRangeForEqualities(const SymSymExpr *Sym) {
1595 std::optional<bool> Equality = meansEquality(Sym);
1601 EquivalenceClass::areEqual(State, Sym->getLHS(), Sym->getRHS())) {
1603 // * if Sym is equality and its operands are known to be equal -> true
1604 // * if Sym is disequality and its operands are disequal -> true
1606 return getTrueRange(Sym->getType());
1609 return getFalseRange(Sym->getType());
1892 ConditionTruthVal checkNull(ProgramStateRef State, SymbolRef Sym) override;
1895 SymbolRef Sym) const override;
1898 SymbolRef Sym) const override;
1901 SymbolRef Sym) const override;
1909 SymbolRef Sym) override;
1924 ProgramStateRef assumeSymNE(ProgramStateRef State, SymbolRef Sym,
1928 ProgramStateRef assumeSymEQ(ProgramStateRef State, SymbolRef Sym,
1932 ProgramStateRef assumeSymLT(ProgramStateRef State, SymbolRef Sym,
1936 ProgramStateRef assumeSymGT(ProgramStateRef State, SymbolRef Sym,
1940 ProgramStateRef assumeSymLE(ProgramStateRef State, SymbolRef Sym,
1944 ProgramStateRef assumeSymGE(ProgramStateRef State, SymbolRef Sym,
1949 ProgramStateRef State, SymbolRef Sym, const llvm::APSInt &From,
1953 ProgramStateRef State, SymbolRef Sym, const llvm::APSInt &From,
1959 RangeSet getRange(ProgramStateRef State, SymbolRef Sym) const;
1960 ProgramStateRef setRange(ProgramStateRef State, SymbolRef Sym,
1963 RangeSet getSymLTRange(ProgramStateRef St, SymbolRef Sym,
1966 RangeSet getSymGTRange(ProgramStateRef St, SymbolRef Sym,
1969 RangeSet getSymLERange(ProgramStateRef St, SymbolRef Sym,
1975 RangeSet getSymGERange(ProgramStateRef St, SymbolRef Sym,
1991 /// bool handle${SYMBOL}To${CONSTRAINT}(const SYMBOL *Sym,
2002 #define DISPATCH(CLASS) return assign##CLASS##Impl(cast<CLASS>(Sym), Constraint)
2008 void assign(SymbolRef Sym, RangeSet Constraint) {
2009 assignImpl(Sym, Constraint);
2012 bool assignImpl(SymbolRef Sym, RangeSet Constraint) {
2013 switch (Sym->getKind()) {
2023 bool assign##Id##To##RangeSet(const Id *Sym, RangeSet Constraint) { \
2026 bool assign##Id##To##Range(const Id *Sym, Range Constraint) { return true; } \
2027 bool assign##Id##To##Const(const Id *Sym, Const Constraint) { return true; }
2035 ASSIGN(Id, Const, Sym, *Const); \
2038 ASSIGN(Id, Range, Sym, *Constraint.begin()); \
2040 ASSIGN(Id, RangeSet, Sym, Constraint)
2046 bool assign##Id##Impl(const Id *Sym, RangeSet Constraint) { \
2055 bool assignSymExprImpl(const SymExpr *Sym, RangeSet Constraint) {
2093 bool handleRemainderOp(const SymT *Sym, RangeSet Constraint) {
2094 if (Sym->getOpcode() != BO_Rem)
2098 SVal SymSVal = Builder.makeSymbolVal(Sym->getLHS());
2108 inline bool assignSymExprToConst(const SymExpr *Sym, Const Constraint);
2109 inline bool assignSymIntExprToRangeSet(const SymIntExpr *Sym,
2111 return handleRemainderOp(Sym, Constraint);
2113 inline bool assignSymSymExprToRangeSet(const SymSymExpr *Sym,
2123 [[nodiscard]] ProgramStateRef assign(SymbolRef Sym, RangeSet NewConstraint) {
2126 State = assign(EquivalenceClass::find(State, Sym), NewConstraint);
2132 Base::assign(Sym, NewConstraint);
2201 bool ConstraintAssignor::assignSymExprToConst(const SymExpr *Sym,
2242 bool ConstraintAssignor::assignSymSymExprToRangeSet(const SymSymExpr *Sym,
2244 if (!handleRemainderOp(Sym, Constraint))
2252 if (std::optional<bool> Equality = meansEquality(Sym)) {
2254 // * if Sym is equality and the new constraint is true -> Sym's operands
2256 // * if Sym is disequality and the new constraint is false -> Sym's
2259 State = trackEquality(State, Sym->getLHS(), Sym->getRHS());
2262 State = trackDisequality(State, Sym->getLHS(), Sym->getRHS());
2312 SymbolRef Sym) {
2314 assert(Sym && "Symbol should not be null");
2316 if (const EquivalenceClass *NontrivialClass = State->get<ClassMap>(Sym))
2319 // This is a trivial class of Sym.
2320 return Sym;
2429 for (SymbolRef Sym : OtherMembers) {
2430 NewClassMembers = F.add(NewClassMembers, Sym);
2432 Classes = CMF.add(Classes, Sym, *this);
2619 // Remove `Old`'s Class->Sym relation.
2632 // Remove `Old`'s Sym->Class relation.
2750 SymbolRef Sym) {
2751 return find(State, Sym).getDisequalClasses(State);
2859 SymbolRef Sym) {
2860 const RangeSet *Ranges = getConstraint(State, Sym);
2871 APSIntType IntType = BV.getAPSIntType(Sym->getType());
2883 SymbolRef Sym) const {
2884 return getRange(St, Sym).getConcreteValue();
2888 SymbolRef Sym) const {
2889 RangeSet Range = getRange(St, Sym);
2894 SymbolRef Sym) const {
2895 RangeSet Range = getRange(St, Sym);
2977 SymbolRef Sym = SymbolClassPair.first;
2979 if (SymReaper.isDead(Sym)) {
2981 NewMap = ClassFactory.remove(NewMap, Sym);
3040 SymbolRef Sym) const {
3041 return SymbolicRangeInferrer::inferRange(F, State, Sym);
3045 SymbolRef Sym,
3047 return ConstraintAssignor::assign(State, getSValBuilder(), F, Sym, Range);
3063 RangeConstraintManager::assumeSymNE(ProgramStateRef St, SymbolRef Sym,
3072 RangeSet New = getRange(St, Sym);
3075 return setRange(St, Sym, New);
3079 RangeConstraintManager::assumeSymEQ(ProgramStateRef St, SymbolRef Sym,
3089 RangeSet New = getRange(St, Sym);
3092 return setRange(St, Sym, New);
3096 RangeConstraintManager::getSymLTRange(ProgramStateRef St, SymbolRef Sym,
3107 return getRange(St, Sym);
3120 RangeSet Result = getRange(St, Sym);
3125 RangeConstraintManager::assumeSymLT(ProgramStateRef St, SymbolRef Sym,
3128 RangeSet New = getSymLTRange(St, Sym, Int, Adjustment);
3129 return setRange(St, Sym, New);
3133 RangeConstraintManager::getSymGTRange(ProgramStateRef St, SymbolRef Sym,
3140 return getRange(St, Sym);
3157 RangeSet SymRange = getRange(St, Sym);
3162 RangeConstraintManager::assumeSymGT(ProgramStateRef St, SymbolRef Sym,
3165 RangeSet New = getSymGTRange(St, Sym, Int, Adjustment);
3166 return setRange(St, Sym, New);
3170 RangeConstraintManager::getSymGERange(ProgramStateRef St, SymbolRef Sym,
3177 return getRange(St, Sym);
3188 return getRange(St, Sym);
3194 RangeSet SymRange = getRange(St, Sym);
3199 RangeConstraintManager::assumeSymGE(ProgramStateRef St, SymbolRef Sym,
3202 RangeSet New = getSymGERange(St, Sym, Int, Adjustment);
3203 return setRange(St, Sym, New);
3236 RangeConstraintManager::getSymLERange(ProgramStateRef St, SymbolRef Sym,
3239 return getSymLERange([&] { return getRange(St, Sym); }, Int, Adjustment);
3243 RangeConstraintManager::assumeSymLE(ProgramStateRef St, SymbolRef Sym,
3246 RangeSet New = getSymLERange(St, Sym, Int, Adjustment);
3247 return setRange(St, Sym, New);
3251 ProgramStateRef State, SymbolRef Sym, const llvm::APSInt &From,
3253 RangeSet New = getSymGERange(State, Sym, From, Adjustment);
3257 return setRange(State, Sym, Out);
3261 ProgramStateRef State, SymbolRef Sym, const llvm::APSInt &From,
3263 RangeSet RangeLT = getSymLTRange(State, Sym, From, Adjustment);
3264 RangeSet RangeGT = getSymGTRange(State, Sym, To, Adjustment);
3266 return setRange(State, Sym, New);
3282 SymbolRef Sym) {
3283 const RangeSet RS = getRange(State, Sym);
3292 static std::string toString(const SymbolRef &Sym) {
3295 Sym->dumpToStream(O);