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

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

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

;

SimpleSValBuilder(llvm::BumpPtrAllocator &alloc,

&context,

~SimpleSValBuilder()

{}

llvm::APSInt &RHS,

resultTy);

SimpleSValBuilder(alloc, context, stateMgr);

ValueBits =

.getSignificantBits();

SimpleSValBuilder::MakeSymIntVal(

*LHS,

llvm::APSInt &RHS,

isIdempotent =

;

makeIntVal(0, resultTy);

isIdempotent =

;

isIdempotent =

;

makeIntVal(0, resultTy);

isIdempotent =

;

makeIntVal(0, resultTy);

(RHS.isAllOnes())

isIdempotent =

;

isIdempotent =

;

(RHS.isAllOnes()) {

std::optional<APSIntPtr> ConvertedRHS = BasicVals.getValue(RHS);

ValWidth = RHS.getBitWidth();

(ValWidth < TypeWidth) {

ConvertedRHS = BasicVals.Convert(SymbolType, RHS);

}

(ValWidth == TypeWidth) {

ConvertedRHS = BasicVals.Convert(SymbolType, RHS);

resultIntTy = BasicVals.getAPSIntType(resultTy);

op = (op == BO_Add) ? BO_Sub : BO_Add;

ConvertedRHS = BasicVals.Convert(resultTy, RHS);

ConvertedRHS = BasicVals.Convert(resultTy, RHS);

makeNonLoc(LHS, op, *ConvertedRHS, resultTy);

&SVB = State->getStateManager().getSValBuilder();

!State->assume(*DV,

);

&SVB = State->getStateManager().getSValBuilder();

);

);

(I <=

) && (I >= -

);

(

*SymInt = dyn_cast<SymIntExpr>(Sym))

std::make_pair(SymInt->getLHS(),

(SymInt->getOpcode() == BO_Add)

? BV.getValue(SymInt->getRHS())

: BV.getValue(-SymInt->getRHS()));

std::make_pair(Sym, BV.getValue(0, Sym->

()));

&SVB = State->getStateManager().getSValBuilder();

assert(SymTy == RSym->

() &&

);

);

);

llvm_unreachable(

);

llvm::APSInt ResultInt;

ResultInt = LInt - RInt;

ResultInt = RInt - LInt;

ResultInt = (Op == BO_Add) ? (LInt + RInt) : (LInt - RInt);

ResultInt = -ResultInt;

}

(ResultInt == 0) {

PersistentResultInt = BV.getValue(ResultInt);

ResultSym, ResultOp, PersistentResultInt, ResultTy));

Sym->

() == Ty &&

(LSym->

() != SingleTy)

assert(!SingleTy.

() &&

);

(!RSym || RSym->

() != SingleTy)

llvm::APSInt LInt, RInt;

simplifiedLhs = simplifySVal(state, lhs);

simplifiedRhs = simplifySVal(state, rhs);

(

simplifiedLhsAsNonLoc = simplifiedLhs.

<

>())

lhs = *simplifiedLhsAsNonLoc;

(

simplifiedRhsAsNonLoc = simplifiedRhs.

<

>())

rhs = *simplifiedRhsAsNonLoc;

makeTruthVal(

, resultTy);

makeTruthVal(

, resultTy);

makeIntVal(0, resultTy);

evalCast(makeIntVal(0,

), resultTy,

evalCast(lhs, resultTy,

{});

makeSymExprValNN(op, lhs, rhs, resultTy);

nonloc::PointerToMemberKind: {

assert(rhs.

() == nonloc::PointerToMemberKind &&

);

LPTMD = LPTM.

(), RPTMD = RPTM.getPTMData();

makeTruthVal(LPTMD == RPTMD, resultTy);

makeTruthVal(LPTMD != RPTMD, resultTy);

nonloc::LocAsIntegerKind: {

nonloc::LocAsIntegerKind:

evalBinOpLL(state, op, lhsL,

nonloc::ConcreteIntKind: {

BasicVals.getAPSIntType(lSym->getType()).apply(i);

BasicVals.getAPSIntType(Context.

).apply(i);

evalBinOpLL(state, op, lhsL, makeLoc(i), resultTy);

makeTruthVal(

, resultTy);

makeTruthVal(

, resultTy);

makeSymExprValNN(op, InputLHS, InputRHS, resultTy);

nonloc::ConcreteIntKind: {

(

llvm::APSInt *KnownRHSValue = getConstValue(state, rhs)) {

llvm::APSInt RHSValue = *KnownRHSValue;

CompareType.

(LHSValue);

CompareType.

(RHSValue);

IntType = BasicVals.getAPSIntType(resultTy);

IntType.

(LHSValue);

IntType.

(RHSValue);

std::optional<APSIntPtr> Result =

BasicVals.evalAPSInt(op, LHSValue, RHSValue);

(op == BO_Shl || op == BO_Shr) {

(LHSValue.isAllOnes() && LHSValue.isSigned())

evalCast(lhs, resultTy,

{});

evalCast(lhs, resultTy,

{});

makeSymExprValNN(op, InputLHS, InputRHS, resultTy);

makeZeroVal(resultTy);

makeSymExprValNN(op, InputLHS, InputRHS, resultTy);

nonloc::SymbolValKind: {

(

*symIntExpr = dyn_cast<SymIntExpr>(Sym)) {

llvm_unreachable(

);

llvm_unreachable(

);

llvm_unreachable(

);

resultTy == getConditionType());

assert(symIntExpr->getType()->isBooleanType() ||

getContext().hasSameUnqualifiedType(symIntExpr->getType(),

getConditionType()));

makeNonLoc(symIntExpr->getLHS(), opc,

symIntExpr->getRHS(), resultTy);

(

llvm::APSInt *RHSValue = getConstValue(state, rhs)) {

IntType = BasicVals.getAPSIntType(resultTy);

llvm::APSInt &first = IntType.

(symIntExpr->getRHS());

llvm::APSInt &second = IntType.

(*RHSValue);

std::optional<APSIntPtr> newRHS;

newRHS = BasicVals.evalAPSInt(BO_Add, first, second);

}

(first >= second) {

newRHS = BasicVals.evalAPSInt(BO_Sub, first, second);

newRHS = BasicVals.evalAPSInt(BO_Sub, second, first);

assert(newRHS &&

);

MakeSymIntVal(symIntExpr, op, *RHSValue, resultTy);

(

llvm::APSInt *RHSValue = getConstValue(state, rhs))

MakeSymIntVal(Sym, op, *RHSValue, resultTy);

(std::optional<NonLoc>

=

(state, op, lhs, rhs, resultTy))

makeSymExprValNN(op, InputLHS, InputRHS, resultTy);

SimpleSValBuilder &SVB) {

SVB.makeTruthVal(

, resultTy);

SVB.makeTruthVal(

, resultTy);

leftFirst = (op == BO_LT || op == BO_LE);

(

*I : RD->

()) {

SVB.makeTruthVal(leftFirst, resultTy);

SVB.makeTruthVal(!leftFirst, resultTy);

llvm_unreachable(

);

&Ctx = State->getStateManager().getContext();

uint64_t RhsBitwidth =

uint64_t LhsBitwidth =

(RhsBitwidth && LhsBitwidth && (LhsLoc.

() == RhsLoc.

())) {

assert(RhsBitwidth == LhsBitwidth &&

);

llvm_unreachable(

);

makeZeroVal(resultTy);

makeTruthVal(

, resultTy);

makeTruthVal(

, resultTy);

llvm_unreachable(

);

loc::GotoLabelKind:

evalCast(lhs, resultTy,

{});

makeTruthVal(

, resultTy);

makeTruthVal(

, resultTy);

loc::ConcreteIntKind: {

makeNonLoc(L.getValue(), op, rSym, resultTy);

makeNonLoc(rSym, op, L.getValue(), resultTy);

(std::optional<APSIntPtr> ResultInt =

BasicVals.evalAPSInt(op, L.getValue(), rInt->getValue()))

assert((isa<loc::MemRegionVal, loc::GotoLabel>(rhs)));

makeTruthVal(

, resultTy);

makeTruthVal(

, resultTy);

loc::MemRegionValKind: {

MakeSymIntVal(lSym, op, rInt->getValue(), resultTy);

(rInt->isZeroConstant()) {

evalCast(lhs, resultTy,

{});

boolType = getContext().BoolTy;

evalBinOpNN(state, op, l, r, resultTy);

assert(LeftMR &&

);

(LeftMS != RightMS &&

((LeftMS != UnknownMS && RightMS != UnknownMS) ||

(isa<StackSpaceRegion>(LeftMS) || isa<StackSpaceRegion>(RightMS)))) {

makeTruthVal(

, resultTy);

makeTruthVal(

, resultTy);

(LeftBase != RightBase &&

((!isa<SymbolicRegion>(LeftBase) && !isa<SymbolicRegion>(RightBase)) ||

(isa<HeapSpaceRegion>(LeftMS) || isa<HeapSpaceRegion>(RightMS))) ){

makeTruthVal(

, resultTy);

makeTruthVal(

, resultTy);

*RightER = dyn_cast<ElementRegion>(RightMR);

*LeftER = dyn_cast<ElementRegion>(LeftMR);

(RightER && LeftER) {

std::optional<NonLoc> LeftIndex = LeftIndexVal.

<

>();

LeftIndexVal = evalCast(*LeftIndex, ArrayIndexTy,

{});

std::optional<NonLoc> RightIndex = RightIndexVal.

<

>();

RightIndexVal = evalCast(*RightIndex, ArrayIndexTy,

{});

evalBinOpNN(state, op, *LeftIndex, *RightIndex, resultTy);

*RightFR = dyn_cast<FieldRegion>(RightMR);

*LeftFR = dyn_cast<FieldRegion>(LeftMR);

(RightFR && LeftFR) {

(LeftOffset.

() !=

&&

makeTruthVal(left < right, resultTy);

makeTruthVal(left > right, resultTy);

makeTruthVal(left <= right, resultTy);

makeTruthVal(left >= right, resultTy);

makeTruthVal(left == right, resultTy);

makeTruthVal(left != right, resultTy);

(LHSSym && RHSSym)

makeNonLoc(LHSSym, op, RHSSym, resultTy);

(op >= BO_PtrMemD && op <= BO_PtrMemI) {

(PTMSV->isNullMemberPointer())

getFieldLValue = [&](

*FD) ->

{

(

&I : *PTMSV)

Result = StateMgr.getStoreManager().evalDerivedToBase(

Result, I->getType(), I->isVirtual());

state->getLValue(FD, Result);

(

*FD = PTMSV->getDeclAs<

>()) {

getFieldLValue(FD);

getFieldLValue(FD);

);

(std::optional<nonloc::ConcreteInt> rhsInt =

(std::optional<loc::ConcreteInt> lhsInt =

llvm::APSInt &leftI = lhsInt->getValue();

assert(leftI.isUnsigned());

llvm::APSInt rightI(rhsInt->getValue(),

);

rightI = rightI.extOrTrunc(leftI.getBitWidth());

llvm::APSInt Multiplicand(rightI.getBitWidth(),

);

Multiplicand = getContext().getTypeSizeInChars(pointeeType).getQuantity();

rightI *= Multiplicand;

rightI = leftI + rightI;

rightI = leftI - rightI;

llvm_unreachable(

);

(

*elemReg = dyn_cast<ElementRegion>(region)) {

assert(op == BO_Add || op == BO_Sub);

index = evalBinOpNN(state, op, elemReg->getIndex(), rhs,

getArrayIndexType());

superR = cast<SubRegion>(elemReg->getSuperRegion());

elementType = elemReg->getElementType();

(isa<SubRegion>(region)) {

assert(op == BO_Add || op == BO_Sub);

index = (op == BO_Add) ? rhs : evalMinus(rhs);

superR = cast<SubRegion>(region);

elementType = getContext().CharTy;

(std::optional<NonLoc> indexV = index.getAs<

>()) {

superR, getContext()));

llvm::APSInt *SimpleSValBuilder::getConstValue(

state,

state->getConstraintManager().getSymVal(state, Sym);

llvm::APSInt *SimpleSValBuilder::getConcreteValue(

) {

->getValue().get();

->getValue().get();

llvm::APSInt *SimpleSValBuilder::getKnownValue(

state,

getConstValue(state, simplifySVal(state,

));

llvm::APSInt *SimpleSValBuilder::getMinValue(

state,

= simplifySVal(state,

);

state->getConstraintManager().getSymMinVal(state, Sym);

llvm::APSInt *SimpleSValBuilder::getMaxValue(

state,

= simplifySVal(state,

);

state->getConstraintManager().getSymMaxVal(state, Sym);

SimplifiedVal = simplifySValOnce(State, Val);

(SimplifiedVal != Val) {

Val = SimplifiedVal;

SimplifiedVal = simplifySValOnce(State, Val);

SimplifiedVal;

simplifyUntilFixpoint(State,

);

llvm::DenseMap<SymbolRef, SVal> Cached;

llvm::APSInt *

=

State->getConstraintManager().getSymVal(State, Sym);

= getConst(Sym);

(

.isUndef())

: State(State), SVB(State->getStateManager().getSValBuilder()) {}

(

llvm::APSInt *I =

State->getConstraintManager().getSymVal(State, S))

I = Cached.find(S);

(I != Cached.end())

LHS = getConstOrVisit(S->getLHS());

(isUnchanged(S->getLHS(), LHS))

S, SVB.

(State, S->getOpcode(), LHS, RHS, S->getType()));

I = Cached.find(S);

(I != Cached.end())

RHS = getConstOrVisit(S->getRHS());

(isUnchanged(S->getRHS(), RHS))

S, SVB.

(State, S->getOpcode(), LHS, RHS, S->getType()));

I = Cached.find(S);

(I != Cached.end())

LHS = getConstOrVisit(S->getLHS());

RHS = getConstOrVisit(S->getRHS());

(isUnchanged(S->getLHS(), LHS) && isUnchanged(S->getRHS(), RHS))

S, SVB.

(State, S->getOpcode(), LHS, RHS, S->getType()));

I = Cached.find(S);

(I != Cached.end())

*OpSym = S->getOperand();

OpVal = getConstOrVisit(OpSym);

(isUnchanged(OpSym, OpVal))

cache(S, SVB.

(OpVal, S->getType(), OpSym->

()));

I = Cached.find(S);

(I != Cached.end())

Op = getConstOrVisit(S->getOperand());

(isUnchanged(S->getOperand(), Op))

S, SVB.

(State, S->getOpcode(), Op, S->getType()));

(

.getSymbol());

SimplifiedV = Simplifier(State).Visit(

);

static std::optional< int64_t > getConcreteValue(NonLoc SV)

static bool isInRelation(BinaryOperator::Opcode Rel, SymbolRef Sym, llvm::APSInt Bound, ProgramStateRef State)

static NonLoc doRearrangeUnchecked(ProgramStateRef State, BinaryOperator::Opcode Op, SymbolRef LSym, llvm::APSInt LInt, SymbolRef RSym, llvm::APSInt RInt)

static bool isNegationValuePreserving(const llvm::APSInt &Value, APSIntType ResultType)

static std::optional< NonLoc > tryRearrange(ProgramStateRef State, BinaryOperator::Opcode Op, NonLoc Lhs, NonLoc Rhs, QualType ResultTy)

static bool shouldRearrange(ProgramStateRef State, BinaryOperator::Opcode Op, SymbolRef Sym, llvm::APSInt Int, QualType Ty)

static SVal evalBinOpFieldRegionFieldRegion(const FieldRegion *LeftFR, const FieldRegion *RightFR, BinaryOperator::Opcode op, QualType resultTy, SimpleSValBuilder &SVB)

static bool isWithinConstantOverflowBounds(SymbolRef Sym, ProgramStateRef State)

static std::pair< SymbolRef, APSIntPtr > decomposeSymbol(SymbolRef Sym, BasicValueFactory &BV)

static void assertEqualBitWidths(ProgramStateRef State, Loc RhsLoc, Loc LhsLoc)

Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...

uint64_t getTypeSize(QualType T) const

Return the size of the specified (complete) type T, in bits.

bool isComparisonOp() const

static Opcode negateComparisonOp(Opcode Opc)

static Opcode reverseComparisonOp(Opcode Opc)

bool isAdditiveOp() const

Represents a member of a struct/union/class.

const RecordDecl * getParent() const

Returns the parent of this field declaration, which is the struct in which this field is defined.

Represents a field injected from an anonymous union/struct into the parent scope.

A (possibly-)qualified type.

bool isNull() const

Return true if this QualType doesn't point to a type yet.

Represents a struct/union/class.

field_range fields() const

bool isBooleanType() const

bool isSignedIntegerOrEnumerationType() const

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

QualType getPointeeType() const

If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee.

bool isIntegralOrEnumerationType() const

Determine whether this type is an integral or enumeration type.

bool isAnyPointerType() const

A safe wrapper around APSInt objects allocated and owned by BasicValueFactory.

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

uint32_t getBitWidth() const

llvm::APSInt getMaxValue() const LLVM_READONLY

Returns the maximum value for this type.

void apply(llvm::APSInt &Value) const

Convert a given APSInt, in place, to match 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.

ElementRegion is used to represent both array elements and casts.

QualType getElementType() const

LLVM_ATTRIBUTE_RETURNS_NONNULL const FieldDecl * getDecl() const override

FullSValVisitor - a convenient mixed visitor for all three: SVal, SymExpr and MemRegion subclasses.

static bool isLocType(QualType T)

RetTy VisitMemRegion(const MemRegion *R)

MemRegion - The root abstract class for all memory regions.

LLVM_ATTRIBUTE_RETURNS_NONNULL const MemSpaceRegion * getMemorySpace() const

RegionOffset getAsOffset() const

Compute the offset within the top level memory object.

LLVM_ATTRIBUTE_RETURNS_NONNULL const MemRegion * getBaseRegion() const

MemSpaceRegion - A memory region that represents a "memory space"; for example, the set of global var...

SValBuilder & getSValBuilder()

Represent a region's offset within the top level base region.

bool hasSymbolicOffset() const

const MemRegion * getRegion() const

It might return null.

int64_t getOffset() const

virtual const llvm::APSInt * getKnownValue(ProgramStateRef state, SVal val)=0

Evaluates a given SVal.

BasicValueFactory & getBasicValueFactory()

virtual SVal evalBinOpLN(ProgramStateRef state, BinaryOperator::Opcode op, Loc lhs, NonLoc rhs, QualType resultTy)=0

Create a new value which represents a binary expression with a memory location and non-location opera...

virtual SVal evalBinOpLL(ProgramStateRef state, BinaryOperator::Opcode op, Loc lhs, Loc rhs, QualType resultTy)=0

Create a new value which represents a binary expression with two memory location operands.

nonloc::ConcreteInt makeIntVal(const IntegerLiteral *integer)

loc::MemRegionVal makeLoc(SymbolRef sym)

virtual const llvm::APSInt * getMinValue(ProgramStateRef state, SVal val)=0

Tries to get the minimal possible (integer) value of a given SVal.

virtual SVal evalBinOpNN(ProgramStateRef state, BinaryOperator::Opcode op, NonLoc lhs, NonLoc rhs, QualType resultTy)=0

Create a new value which represents a binary expression with two non- location operands.

DefinedSVal makeSymbolVal(SymbolRef Sym)

Make an SVal that represents the given symbol.

SVal evalCast(SVal V, QualType CastTy, QualType OriginalTy)

Cast a given SVal to another SVal using given QualType's.

const AnalyzerOptions & getAnalyzerOptions() const

virtual SVal simplifySVal(ProgramStateRef State, SVal Val)=0

Simplify symbolic expressions within a given SVal.

QualType getConditionType() const

SVal evalUnaryOp(ProgramStateRef state, UnaryOperator::Opcode opc, SVal operand, QualType type)

virtual const llvm::APSInt * getMaxValue(ProgramStateRef state, SVal val)=0

Tries to get the maximal possible (integer) value of a given SVal.

SymbolManager & getSymbolManager()

SVal evalBinOp(ProgramStateRef state, BinaryOperator::Opcode op, SVal lhs, SVal rhs, QualType type)

loc::ConcreteInt makeIntLocVal(const llvm::APSInt &integer)

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

bool isZeroConstant() const

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.

QualType getType(const ASTContext &) const

Try to get a reasonable type for the given value.

SymbolRef getAsLocSymbol(bool IncludeBaseRegions=false) const

If this SVal is a location and wraps a symbol, return that SymbolRef.

const MemRegion * getAsRegion() const

T castAs() const

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

SubRegion - A region that subsets another larger region.

LLVM_ATTRIBUTE_RETURNS_NONNULL const MemRegion * getSuperRegion() const

RetTy VisitSymExpr(SymbolRef S)

virtual QualType getType() const =0

Represents a cast expression.

A symbol representing data which can be stored in a memory location (region).

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

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

Represents a symbolic expression involving a unary operator.

Value representing integer constant.

Value representing pointer-to-member.

const PTMDataType getPTMData() const

Represents symbolic expression that isn't a location.

SValBuilder * createSimpleSValBuilder(llvm::BumpPtrAllocator &alloc, ASTContext &context, ProgramStateManager &stateMgr)

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

bool Ret(InterpState &S, CodePtr &PC)

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

const FunctionProtoType * T

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