59 SVal LeftV = state->getSVal(LHS, LCtx);
60 SVal RightV = state->getSVal(RHS, LCtx);
64 if (Op == BO_Assign) {
75 evalStore(Tmp2, B, LHS, *it, state->BindExpr(B, LCtx, ExprVal),
99 state = createTemporaryRegionIfNeeded(state, LCtx, LHS);
104 if (!
Result.isUnknown()) {
105 state = state->BindExpr(B, LCtx,
Result);
120 llvm_unreachable(
"Invalid opcode for compound assignment.");
121 case BO_MulAssign: Op = BO_Mul;
break;
122 case BO_DivAssign: Op = BO_Div;
break;
123 case BO_RemAssign: Op = BO_Rem;
break;
124 case BO_AddAssign: Op = BO_Add;
break;
125 case BO_SubAssign: Op = BO_Sub;
break;
126 case BO_ShlAssign: Op = BO_Shl;
break;
127 case BO_ShrAssign: Op = BO_Shr;
break;
128 case BO_AndAssign: Op = BO_And;
break;
129 case BO_XorAssign: Op = BO_Xor;
break;
130 case BO_OrAssign: Op = BO_Or;
break;
136 SVal location = LeftV;
137 evalLoad(Tmp, B, LHS, *it, state, location);
140 state = N->getState();
142 SVal V = state->getSVal(LHS, LCtx);
146 cast<CompoundAssignOperator>(B)->getComputationResultType();
150 cast<CompoundAssignOperator>(B)->getComputationLHSType();
185 state = state->BindExpr(B, LCtx, location);
187 state = state->BindExpr(B, LCtx,
Result);
189 evalStore(Tmp2, B, LHS, N, state, location, LHSVal);
213 dyn_cast_or_null<BlockDataRegion>(
V.getAsRegion())) {
215 auto ReferencedVars = BDR->referenced_vars();
218 for (
auto Var : ReferencedVars) {
219 const VarRegion *capturedR = Var.getCapturedRegion();
228 const Expr *copyExpr =
nullptr;
230 assert(CI->getVariable() == capturedR->
getDecl());
231 copyExpr = CI->getCopyExpr();
235 if (capturedR != originalR) {
239 originalV = State->getSVal(copyExpr, LCtx);
270 SVal OrigV = state->getSVal(Ex, LCtx);
274 if (CastE->
getCastKind() == CK_BooleanToSignedIntegral &&
V.isValid())
277 state = state->BindExpr(CastE, LCtx,
V);
296 evalLoad(Dst, CastE, CastE,
Node, State, State->getSVal(Ex, LCtx));
300 if (CastE->
getCastKind() == CK_LValueToRValueBitCast) {
308 evalLocation(DstEvalLoc, CastE, Ex,
Node, State, State->getSVal(Ex, LCtx),
323 if (
const MemRegion *MR = State->getSVal(Ex, LCtx).getAsRegion()) {
324 SVal OrigV = State->getSVal(MR);
328 State = State->BindExpr(CastE, LCtx, CastedV);
338 if (
const ExplicitCastExpr *ExCast=dyn_cast_or_null<ExplicitCastExpr>(CastE))
339 T = ExCast->getTypeAsWritten();
347 case CK_LValueToRValue:
348 case CK_LValueToRValueBitCast:
349 llvm_unreachable(
"LValueToRValue casts handled earlier.");
354 case CK_ARCProduceObject:
355 case CK_ARCConsumeObject:
356 case CK_ARCReclaimReturnedObject:
357 case CK_ARCExtendBlockObject:
358 case CK_CopyAndAutoreleaseBlockObject:
362 case CK_AtomicToNonAtomic:
363 case CK_NonAtomicToAtomic:
366 case CK_ConstructorConversion:
367 case CK_UserDefinedConversion:
368 case CK_FunctionToPointerDecay:
369 case CK_BuiltinFnToFnPtr:
370 case CK_HLSLArrayRValue: {
374 SVal V = state->getSVal(Ex, LCtx);
375 state = state->BindExpr(CastE, LCtx,
V);
379 case CK_MemberPointerToBoolean:
380 case CK_PointerToBoolean: {
381 SVal V = state->getSVal(Ex, LCtx);
384 V = svalBuilder.
makeTruthVal(!PTMSV->isNullMemberPointer(), ExTy);
385 if (
V.isUndef() || PTMSV) {
386 state = state->BindExpr(CastE, LCtx,
V);
396 case CK_ArrayToPointerDecay:
398 case CK_AddressSpaceConversion:
399 case CK_BooleanToSignedIntegral:
400 case CK_IntegralToPointer:
401 case CK_PointerToIntegral: {
402 SVal V = state->getSVal(Ex, LCtx);
403 if (isa<nonloc::PointerToMember>(
V)) {
404 state = state->BindExpr(CastE, LCtx,
UnknownVal());
413 case CK_IntegralToBoolean:
414 case CK_IntegralToFloating:
415 case CK_FloatingToIntegral:
416 case CK_FloatingToBoolean:
417 case CK_FloatingCast:
418 case CK_FloatingRealToComplex:
419 case CK_FloatingComplexToReal:
420 case CK_FloatingComplexToBoolean:
421 case CK_FloatingComplexCast:
422 case CK_FloatingComplexToIntegralComplex:
423 case CK_IntegralRealToComplex:
424 case CK_IntegralComplexToReal:
425 case CK_IntegralComplexToBoolean:
426 case CK_IntegralComplexCast:
427 case CK_IntegralComplexToFloatingComplex:
428 case CK_CPointerToObjCPointerCast:
429 case CK_BlockPointerToObjCPointerCast:
430 case CK_AnyPointerToBlockPointerCast:
431 case CK_ObjCObjectLValueCast:
432 case CK_ZeroToOCLOpaqueType:
433 case CK_IntToOCLSampler:
434 case CK_LValueBitCast:
435 case CK_FloatingToFixedPoint:
436 case CK_FixedPointToFloating:
437 case CK_FixedPointCast:
438 case CK_FixedPointToBoolean:
439 case CK_FixedPointToIntegral:
440 case CK_IntegralToFixedPoint: {
445 case CK_IntegralCast: {
447 SVal V = state->getSVal(Ex, LCtx);
448 if (AMgr.
options.ShouldSupportSymbolicIntegerCasts)
452 state = state->BindExpr(CastE, LCtx,
V);
456 case CK_DerivedToBase:
457 case CK_UncheckedDerivedToBase: {
459 SVal val = state->getSVal(Ex, LCtx);
461 state = state->BindExpr(CastE, LCtx, val);
467 SVal val = state->getSVal(Ex, LCtx);
478 if (std::optional<SVal>
V =
492 state = state->BindExpr(CastE, LCtx,
501 state = state->BindExpr(CastE, LCtx, NewSym);
504 state = state->BindExpr(CastE, LCtx, val);
509 case CK_BaseToDerived: {
510 SVal val = state->getSVal(Ex, LCtx);
526 state = state->BindExpr(CastE, LCtx, val);
530 case CK_NullToPointer: {
532 state = state->BindExpr(CastE, LCtx,
V);
536 case CK_NullToMemberPointer: {
538 state = state->BindExpr(CastE, LCtx,
V);
542 case CK_DerivedToBaseMemberPointer:
543 case CK_BaseToDerivedMemberPointer:
544 case CK_ReinterpretMemberPointer: {
545 SVal V = state->getSVal(Ex, LCtx);
550 state = state->BindExpr(CastE, LCtx, CastedPTMSV);
561 case CK_HLSLElementwiseCast:
562 case CK_HLSLAggregateSplatCast:
563 case CK_HLSLVectorTruncation: {
570 state = state->BindExpr(CastE, LCtx, result);
587 SVal V = State->getSVal(
CL->getInitializer(), LCtx);
589 if (isa<CXXConstructExpr, CXXStdInitializerListExpr>(
Init)) {
592 assert(isa<InitListExpr>(
Init));
593 Loc CLLoc = State->getLValue(
CL, LCtx);
594 State = State->bindLoc(CLLoc,
V, LCtx);
605 if (isa<TypedefNameDecl>(*DS->
decl_begin())) {
643 SVal InitVal = state->getSVal(InitEx, LC);
647 state = finishObjectConstruction(state, DS, LC);
656 if (InitEx->isGLValue()) {
668 evalBind(Dst2, DS, UpdatedN, state->getLValue(VD, LC), InitVal,
true);
742 if (
const BinaryOperator *Term = cast_or_null<BinaryOperator>(
T.getStmt())) {
744 assert(Term->isLogicalOp());
754 assert(!SrcBlock->
empty());
789 auto Edge = N->getLocationAs<
BlockEdge>();
790 if (!Edge.has_value()) {
798 SrcBlock = Edge->getSrc();
799 SrcState = N->getState();
803 assert(SrcBlock &&
"missing function entry");
807 bool hasValue =
false;
810 for (
CFGElement CE : llvm::reverse(*SrcBlock)) {
811 if (std::optional<CFGStmt> CS = CE.getAs<
CFGStmt>()) {
812 const Expr *ValEx = cast<Expr>(CS->getStmt());
818 L = OpaqueEx->getSourceExpr();
824 V = SrcState->getSVal(ValEx, LCtx);
835 B.
generateNode(Ex, Pred, state->BindExpr(Ex, LCtx,
V,
true));
871 if (Ex->
getKind() == UETT_SizeOf || Ex->
getKind() == UETT_DataSizeOf ||
872 Ex->
getKind() == UETT_CountOf) {
891 state = state->BindExpr(
892 Ex, N->getLocationContext(),
909 const Expr *Ex =
U->getSubExpr()->IgnoreParens();
912 Bldr.
generateNode(
U, N, state->BindExpr(
U, LCtx, state->getSVal(Ex, LCtx)));
925 switch (
U->getOpcode()) {
934 const Expr *Ex =
U->getSubExpr()->IgnoreParens();
943 assert (
U->getType() == Ex->
getType());
947 state->BindExpr(
U, LCtx, state->getSVal(Ex, LCtx)));
952 const Expr *Ex =
U->getSubExpr()->IgnoreParens();
968 const Expr *Ex =
U->getSubExpr()->IgnoreParens();
969 if (
const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Ex)) {
972 if (isa<CXXMethodDecl, FieldDecl, IndirectFieldDecl>(VD)) {
985 assert(!
U->isGLValue());
996 assert (!
U->isGLValue());
997 const Expr *Ex =
U->getSubExpr()->IgnoreParens();
1002 SVal V = state->getSVal(Ex, LCtx);
1004 if (
V.isUnknownOrUndef()) {
1009 switch (
U->getOpcode()) {
1011 llvm_unreachable(
"Invalid Opcode.");
1014 state = state->BindExpr(
1019 state = state->BindExpr(
U, LCtx,
1028 if (std::optional<Loc> LV =
V.getAs<
Loc>()) {
1039 state = state->BindExpr(
U, LCtx,
Result);
1055 assert (
U->isIncrementDecrementOp());
1056 const Expr *Ex =
U->getSubExpr()->IgnoreParens();
1060 SVal loc = state->getSVal(Ex, LCtx);
1069 state = N->getState();
1070 assert(LCtx == N->getLocationContext());
1071 SVal V2_untested = state->getSVal(Ex, LCtx);
1075 state = state->BindExpr(
U, LCtx, V2_untested);
1080 evalStore(Dst3,
U, Ex, N, state, loc, V2_untested);
1096 if (
U->getType()->isAnyPointerType())
1098 else if (
U->getType()->isIntegralOrEnumerationType())
1107 if (
U->getType()->isBooleanType() &&
U->isIncrementOp())
1126 if (!state->assume(Constraint,
true)) {
1129 Constraint = svalBuilder.
evalEQ(state, SymVal,
1132 state = state->assume(Constraint,
false);
1141 state = state->BindExpr(
U, LCtx, loc);
1143 state = state->BindExpr(
U, LCtx,
U->isPostfix() ? V2 :
Result);
Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate....
Defines the clang::Expr interface and subclasses for C++ expressions.
static SVal conjureOffsetSymbolOnLocation(SVal Symbol, SVal Other, ConstCFGElementRef Elem, QualType Ty, SValBuilder &svalBuilder, unsigned Count, const LocationContext *LCtx)
Optionally conjure and return a symbol for offset when processing Elem.
QualType getRValueReferenceType(QualType T) const
Return the uniqued reference to the type for an rvalue reference to the specified type.
CanQualType getCanonicalType(QualType T) const
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
QualType getPointerType(QualType T) const
Return the uniqued reference to the type for a pointer to the specified type.
QualType getLValueReferenceType(QualType T, bool SpelledAsLValue=true) const
Return the uniqued reference to the type for an lvalue reference to the specified type.
A builtin binary operation expression such as "x + y" or "x <= y".
static bool isAdditiveOp(Opcode Opc)
static bool isAssignmentOp(Opcode Opc)
static bool isCompoundAssignmentOp(Opcode Opc)
Represents a block literal declaration, which is like an unnamed FunctionDecl.
capture_const_iterator capture_begin() const
capture_const_iterator capture_end() const
const CFGBlock * getSrc() const
const CFGBlock * getDst() const
BlockExpr - Adaptor class for mixing a BlockDecl with expressions.
const BlockDecl * getBlockDecl() const
This class is used for builtin types like 'int'.
Represents a single basic block in a source-level CFG.
reverse_iterator rbegin()
CFGTerminator getTerminator() const
succ_iterator succ_begin()
unsigned succ_size() const
Represents a top-level expression in a basic block.
T castAs() const
Convert to the specified CFGElement type, asserting that this CFGElement is of the desired type.
const Stmt * getStmt() const
Represents CFGBlock terminator statement.
CastExpr - Base class for type casts, including both implicit casts (ImplicitCastExpr) and explicit c...
CastKind getCastKind() const
llvm::iterator_range< path_iterator > path()
Path through the class hierarchy taken by casts between base and derived classes (see implementation ...
CharUnits - This is an opaque type for sizes expressed in character units.
QuantityType getQuantity() const
getQuantity - Get the raw integer representation of this quantity.
static CharUnits fromQuantity(QuantityType Quantity)
fromQuantity - Construct a CharUnits quantity from a raw integer type.
CompoundLiteralExpr - [C99 6.5.2.5].
A reference to a declared variable, function, enum, etc.
DeclStmt - Adaptor class for mixing declarations with statements and expressions.
bool isSingleDecl() const
isSingleDecl - This method returns true if this DeclStmt refers to a single Decl.
decl_iterator decl_begin()
ExplicitCastExpr - An explicit cast written in the source code.
This represents one expression.
bool EvaluateAsInt(EvalResult &Result, const ASTContext &Ctx, SideEffectsKind AllowSideEffects=SE_NoSideEffects, bool InConstantContext=false) const
EvaluateAsInt - Return true if this is a constant which we can fold and convert to an integer,...
llvm::APSInt EvaluateKnownConstInt(const ASTContext &Ctx, SmallVectorImpl< PartialDiagnosticAt > *Diag=nullptr) const
EvaluateKnownConstInt - Call EvaluateAsRValue and return the folded integer.
Expr * IgnoreParens() LLVM_READONLY
Skip past any parentheses which might surround this expression until reaching a fixed point.
It wraps the AnalysisDeclContext to represent both the call stack with the help of StackFrameContext ...
Represents a class type in Objective C.
OffsetOfExpr - [C99 7.17] - This represents an expression of the form offsetof(record-type,...
OpaqueValueExpr - An expression referring to an opaque object of a fixed type and value class.
Represents a point after we ran remove dead bindings BEFORE processing the given statement.
T castAs() const
Convert to the specified ProgramPoint type, asserting that this ProgramPoint is of the desired type.
std::optional< T > getAs() const
Convert to the specified ProgramPoint type, returning std::nullopt if this ProgramPoint is not of the...
A (possibly-)qualified type.
bool isSignedIntegerType() const
Return true if this is an integer type that is signed, according to C99 6.2.5p4 [char,...
bool isRValueReferenceType() const
bool isConstantSizeType() const
Return true if this is not a variable sized type, according to the rules of C99 6....
const T * castAs() const
Member-template castAs<specific type>.
bool isReferenceType() const
bool isVariableArrayType() const
bool isIntegralOrEnumerationType() const
Determine whether this type is an integral or enumeration type.
bool isLValueReferenceType() const
bool isAnyComplexType() const
bool isIncompleteType(NamedDecl **Def=nullptr) const
Types are partitioned into 3 broad categories (C99 6.2.5p1): object types, function types,...
bool isVectorType() const
bool isFloatingType() const
const T * getAs() const
Member-template getAs<specific type>'.
UnaryExprOrTypeTraitExpr - expression with either a type or (unevaluated) expression operand.
QualType getTypeOfArgument() const
Gets the argument type, or the type of the argument expression, whichever is appropriate.
UnaryExprOrTypeTrait getKind() const
UnaryOperator - This represents the unary-expression's (except sizeof and alignof),...
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
Represents a variable declaration or definition.
const Expr * getInit() const
AnalyzerOptions & options
BlockDataRegion - A region that represents a block instance.
void runCheckersForPostStmt(ExplodedNodeSet &Dst, const ExplodedNodeSet &Src, const Stmt *S, ExprEngine &Eng, bool wasInlined=false)
Run checkers for post-visiting Stmts.
void runCheckersForPreStmt(ExplodedNodeSet &Dst, const ExplodedNodeSet &Src, const Stmt *S, ExprEngine &Eng)
Run checkers for pre-visiting Stmts.
ImplTy::iterator iterator
void insert(const ExplodedNodeSet &S)
const ProgramStateRef & getState() const
pred_iterator pred_begin()
ProgramPoint getLocation() const
getLocation - Returns the edge associated with the given node.
unsigned pred_size() const
const LocationContext * getLocationContext() const
void VisitBinaryOperator(const BinaryOperator *B, ExplodedNode *Pred, ExplodedNodeSet &Dst)
VisitBinaryOperator - Transfer function logic for binary operators.
void VisitGuardedExpr(const Expr *Ex, const Expr *L, const Expr *R, ExplodedNode *Pred, ExplodedNodeSet &Dst)
VisitGuardedExpr - Transfer function logic for ?, __builtin_choose.
void VisitCast(const CastExpr *CastE, const Expr *Ex, ExplodedNode *Pred, ExplodedNodeSet &Dst)
VisitCast - Transfer function logic for all casts (implicit and explicit).
BasicValueFactory & getBasicVals()
void VisitLogicalExpr(const BinaryOperator *B, ExplodedNode *Pred, ExplodedNodeSet &Dst)
VisitLogicalExpr - Transfer function logic for '&&', '||'.
SVal evalBinOp(ProgramStateRef ST, BinaryOperator::Opcode Op, SVal LHS, SVal RHS, QualType T)
void VisitUnaryOperator(const UnaryOperator *B, ExplodedNode *Pred, ExplodedNodeSet &Dst)
VisitUnaryOperator - Transfer function logic for unary operators.
void VisitDeclStmt(const DeclStmt *DS, ExplodedNode *Pred, ExplodedNodeSet &Dst)
VisitDeclStmt - Transfer function logic for DeclStmts.
ProgramStateRef handleLValueBitCast(ProgramStateRef state, const Expr *Ex, const LocationContext *LCtx, QualType T, QualType ExTy, const CastExpr *CastE, StmtNodeBuilder &Bldr, ExplodedNode *Pred)
static std::optional< SVal > getObjectUnderConstruction(ProgramStateRef State, const ConstructionContextItem &Item, const LocationContext *LC)
By looking at a certain item that may be potentially part of an object's ConstructionContext,...
void VisitBlockExpr(const BlockExpr *BE, ExplodedNode *Pred, ExplodedNodeSet &Dst)
VisitBlockExpr - Transfer function logic for BlockExprs.
void VisitIncrementDecrementOperator(const UnaryOperator *U, ExplodedNode *Pred, ExplodedNodeSet &Dst)
Handle ++ and – (both pre- and post-increment).
ASTContext & getContext() const
getContext - Return the ASTContext associated with this analysis.
StoreManager & getStoreManager()
ConstCFGElementRef getCFGElementRef() const
void VisitUnaryExprOrTypeTraitExpr(const UnaryExprOrTypeTraitExpr *Ex, ExplodedNode *Pred, ExplodedNodeSet &Dst)
VisitUnaryExprOrTypeTraitExpr - Transfer function for sizeof.
ProgramStateRef escapeValues(ProgramStateRef State, ArrayRef< SVal > Vs, PointerEscapeKind K, const CallEvent *Call=nullptr) const
A simple wrapper when you only need to notify checkers of pointer-escape of some values.
CheckerManager & getCheckerManager() const
void VisitOffsetOfExpr(const OffsetOfExpr *Ex, ExplodedNode *Pred, ExplodedNodeSet &Dst)
VisitOffsetOfExpr - Transfer function for offsetof.
void evalLoad(ExplodedNodeSet &Dst, const Expr *NodeEx, const Expr *BoundExpr, ExplodedNode *Pred, ProgramStateRef St, SVal location, const ProgramPointTag *tag=nullptr, QualType LoadTy=QualType())
Simulate a read of the result of Ex.
void handleUOExtension(ExplodedNode *N, const UnaryOperator *U, StmtNodeBuilder &Bldr)
void VisitCompoundLiteralExpr(const CompoundLiteralExpr *CL, ExplodedNode *Pred, ExplodedNodeSet &Dst)
VisitCompoundLiteralExpr - Transfer function logic for compound literals.
void evalStore(ExplodedNodeSet &Dst, const Expr *AssignE, const Expr *StoreE, ExplodedNode *Pred, ProgramStateRef St, SVal TargetLV, SVal Val, const ProgramPointTag *tag=nullptr)
evalStore - Handle the semantics of a store via an assignment.
static bool isLocType(QualType T)
MemRegion - The root abstract class for all memory regions.
unsigned blockCount() const
Returns the number of times the current basic block has been visited on the exploded graph path.
void takeNodes(const ExplodedNodeSet &S)
void addNodes(const ExplodedNodeSet &S)
const ExplodedNodeSet & getResults()
StoreManager & getStoreManager()
DefinedOrUnknownSVal makeZeroVal(QualType type)
Construct an SVal representing '0' for the specified type.
DefinedSVal getMemberPointer(const NamedDecl *ND)
NonLoc makePointerToMember(const DeclaratorDecl *DD)
SVal evalMinus(NonLoc val)
SVal evalComplement(NonLoc val)
DefinedSVal getBlockPointer(const BlockDecl *block, CanQualType locTy, const LocationContext *locContext, unsigned blockCount)
NonLoc makeArrayIndex(uint64_t idx)
nonloc::ConcreteInt makeIntVal(const IntegerLiteral *integer)
SVal evalCast(SVal V, QualType CastTy, QualType OriginalTy)
Cast a given SVal to another SVal using given QualType's.
virtual SVal simplifySVal(ProgramStateRef State, SVal Val)=0
Simplify symbolic expressions within a given SVal.
SVal evalEQ(ProgramStateRef state, SVal lhs, SVal rhs)
nonloc::ConcreteInt makeTruthVal(bool b, QualType type)
loc::ConcreteInt makeNullWithType(QualType type)
Create NULL pointer, with proper pointer bit-width for given address space.
DefinedOrUnknownSVal conjureSymbolVal(const void *symbolTag, ConstCFGElementRef elem, const LocationContext *LCtx, unsigned count)
Create a new symbol with a unique 'name'.
SVal evalIntegralCast(ProgramStateRef state, SVal val, QualType castTy, QualType originalType)
SVal - This represents a symbolic expression, which can be either an L-value or an R-value.
bool isZeroConstant() const
bool isUnknownOrUndef() const
T castAs() const
Convert to the specified SVal type, asserting that this SVal is of the desired type.
This builder class is useful for generating nodes that resulted from visiting a statement.
ExplodedNode * generateNode(const Stmt *S, ExplodedNode *Pred, ProgramStateRef St, const ProgramPointTag *tag=nullptr, ProgramPoint::Kind K=ProgramPoint::PostStmtKind)
ExplodedNode * generateSink(const Stmt *S, ExplodedNode *Pred, ProgramStateRef St, const ProgramPointTag *tag=nullptr, ProgramPoint::Kind K=ProgramPoint::PostStmtKind)
SVal evalDerivedToBase(SVal Derived, const CastExpr *Cast)
Evaluates a chain of derived-to-base casts through the path specified in Cast.
std::optional< SVal > evalBaseToDerived(SVal Base, QualType DerivedPtrType)
Attempts to do a down cast.
TypedValueRegion - An abstract class representing regions having a typed value.
const VarDecl * getDecl() const override=0
Value representing integer constant.
Value representing pointer-to-member.
@ PSK_EscapeOther
The reason for pointer escape is unknown.
The JSON file list parser is used to communicate input to InstallAPI.
CFGBlock::ConstCFGElementRef ConstCFGElementRef
@ Result
The result type of a method or function.
const FunctionProtoType * T
@ Other
Other implicit parameter.
EvalResult is a struct with detailed info about an evaluated expression.