|
|
reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced
|
Derived Classes
tools/clang/include/clang/AST/Expr.h 925 class FullExpr : public Expr {
1050 class OpaqueValueExpr : public Expr {
1146 class DeclRefExpr final
1421 class IntegerLiteral : public Expr, public APIntStorage {
1464 class FixedPointLiteral : public Expr, public APIntStorage {
1505 class CharacterLiteral : public Expr {
1558 class FloatingLiteral : public Expr, private APFloatStorage {
1637 class ImaginaryLiteral : public Expr {
1686 class StringLiteral final
1878 class PredefinedExpr final
1969 class ParenExpr : public Expr {
2021 class UnaryOperator : public Expr {
2242 class OffsetOfExpr final
2347 class UnaryExprOrTypeTraitExpr : public Expr {
2437 class ArraySubscriptExpr : public Expr {
2521 class CallExpr : public Expr {
2811 class MemberExpr final
3052 class CompoundLiteralExpr : public Expr {
3125 class CastExpr : public Expr {
3409 class BinaryOperator : public Expr {
3665 class AbstractConditionalOperator : public Expr {
3882 class AddrLabelExpr : public Expr {
3926 class StmtExpr : public Expr {
3971 class ShuffleVectorExpr : public Expr {
4039 class ConvertVectorExpr : public Expr {
4102 class ChooseExpr : public Expr {
4182 class GNUNullExpr : public Expr {
4216 class VAArgExpr : public Expr {
4267 class SourceLocExpr final : public Expr {
4375 class InitListExpr : public Expr {
4611 class DesignatedInitExpr final
4909 class NoInitExpr : public Expr {
4945 class DesignatedInitUpdateExpr : public Expr {
4999 class ArrayInitLoopExpr : public Expr {
5054 class ArrayInitIndexExpr : public Expr {
5089 class ImplicitValueInitExpr : public Expr {
5115 class ParenListExpr final
5206 class GenericSelectionExpr final
5490 class ExtVectorElementExpr : public Expr {
5551 class BlockExpr : public Expr {
5600 class AsTypeExpr : public Expr {
5673 class PseudoObjectExpr final
5807 class AtomicExpr : public Expr {
5936 class TypoExpr : public Expr {
tools/clang/include/clang/AST/ExprCXX.h 273 class CXXRewrittenBinaryOperator : public Expr {
645 class CXXBoolLiteralExpr : public Expr {
683 class CXXNullPtrLiteralExpr : public Expr {
715 class CXXStdInitializerListExpr : public Expr {
764 class CXXTypeidExpr : public Expr {
863 class MSPropertyRefExpr : public Expr {
937 class MSPropertySubscriptExpr : public Expr {
1000 class CXXUuidofExpr : public Expr {
1097 class CXXThisExpr : public Expr {
1140 class CXXThrowExpr : public Expr {
1202 class CXXDefaultArgExpr final : public Expr {
1279 class CXXDefaultInitExpr : public Expr {
1373 class CXXBindTemporaryExpr : public Expr {
1422 class CXXConstructExpr : public Expr {
1613 class CXXInheritedCtorInitExpr : public Expr {
1818 class LambdaExpr final : public Expr,
2053 class CXXScalarValueInitExpr : public Expr {
2100 class CXXNewExpr final
2359 class CXXDeleteExpr : public Expr {
2479 class CXXPseudoDestructorExpr : public Expr {
2627 class TypeTraitExpr final
2715 class ArrayTypeTraitExpr : public Expr {
2785 class ExpressionTraitExpr : public Expr {
2844 class OverloadExpr : public Expr {
3155 class DependentScopeDeclRefExpr final
3390 class CXXUnresolvedConstructExpr final
3511 class CXXDependentScopeMemberExpr final
3958 class CXXNoexceptExpr : public Expr {
4015 class PackExpansionExpr : public Expr {
4091 class SizeOfPackExpr final
4209 class SubstNonTypeTemplateParmExpr : public Expr {
4269 class SubstNonTypeTemplateParmPackExpr : public Expr {
4337 class FunctionParmPackExpr final
4419 class MaterializeTemporaryExpr : public Expr {
4535 class CXXFoldExpr : public Expr {
4618 class CoroutineSuspendExpr : public Expr {
4741 class DependentCoawaitExpr : public Expr {
4849 class ConceptSpecializationExpr final : public Expr,
tools/clang/include/clang/AST/ExprObjC.h 50 class ObjCStringLiteral : public Expr {
85 class ObjCBoolLiteralExpr : public Expr {
124 class ObjCBoxedExpr : public Expr {
188 class ObjCArrayLiteral final
304 class ObjCDictionaryLiteral final
407 class ObjCEncodeExpr : public Expr {
454 class ObjCSelectorExpr : public Expr {
503 class ObjCProtocolExpr : public Expr {
546 class ObjCIvarRefExpr : public Expr {
614 class ObjCPropertyRefExpr : public Expr {
845 class ObjCSubscriptRefExpr : public Expr {
950 class ObjCMessageExpr final
1492 class ObjCIsaExpr : public Expr {
1577 class ObjCIndirectCopyRestoreExpr : public Expr {
1699 class ObjCAvailabilityCheckExpr : public Expr {
tools/clang/include/clang/AST/ExprOpenMP.h 44 class OMPArraySectionExpr : public Expr {
Declarations
gen/tools/clang/include/clang/AST/StmtNodes.inc 569 ABSTRACT_STMT(EXPR(Expr, ValueStmt))
tools/clang/include/clang/AST/APValue.h 30 class Expr;
tools/clang/include/clang/AST/ASTContext.h 97 class Expr;
tools/clang/include/clang/AST/ASTImporter.h 42 class Expr;
tools/clang/include/clang/AST/ASTMutationListener.h 24 class Expr;
tools/clang/include/clang/AST/Attr.h 39 class Expr;
tools/clang/include/clang/AST/CanonicalType.h 35 class Expr;
tools/clang/include/clang/AST/CurrentSourceLocExprScope.h 21 class Expr;
tools/clang/include/clang/AST/Decl.h 59 class Expr;
tools/clang/include/clang/AST/DeclObjC.h 48 class Expr;
tools/clang/include/clang/AST/DeclTemplate.h 47 class Expr;
tools/clang/include/clang/AST/NSAPI.h 20 class Expr;
tools/clang/include/clang/AST/ParentMap.h 18 class Expr;
tools/clang/include/clang/AST/SelectorLocationsKind.h 22 class Expr;
tools/clang/include/clang/AST/Stmt.h 48 class Expr;
tools/clang/include/clang/AST/TemplateBase.h 44 class Expr;
tools/clang/include/clang/AST/Type.h 106 class Expr;
tools/clang/include/clang/AST/TypeLoc.h 38 class Expr;
tools/clang/include/clang/Analysis/Analyses/ThreadSafetyCommon.h 53 class Expr;
tools/clang/include/clang/Analysis/Analyses/ThreadSafetyTIL.h 69 class Expr;
tools/clang/include/clang/Analysis/Analyses/ThreadSafetyUtil.h 31 class Expr;
tools/clang/include/clang/Analysis/Analyses/UninitializedValues.h 25 class Expr;
tools/clang/include/clang/Analysis/PathDiagnostic.h 47 class Expr;
tools/clang/include/clang/Index/IndexDataConsumer.h 18 class Expr;
tools/clang/include/clang/Sema/Designator.h 22 class Expr;
tools/clang/include/clang/Sema/Ownership.h 34 class Expr;
tools/clang/include/clang/Sema/ParsedAttr.h 37 class Expr;
tools/clang/include/clang/Sema/Sema.h 118 class Expr;
tools/clang/include/clang/Serialization/ASTReader.h 88 class Expr;
tools/clang/include/clang/StaticAnalyzer/Core/BugReporter/BugReporterVisitors.h 31 class Expr;
tools/clang/include/clang/StaticAnalyzer/Core/PathSensitive/CheckerHelpers.h 21 class Expr;
tools/clang/include/clang/StaticAnalyzer/Core/PathSensitive/CoreEngine.h 38 class Expr;
tools/clang/include/clang/StaticAnalyzer/Core/PathSensitive/ExplodedGraph.h 48 class Expr;
tools/clang/include/clang/StaticAnalyzer/Core/PathSensitive/Store.h 39 class Expr;
tools/clang/lib/AST/CXXABI.h 24 class Expr;
tools/clang/lib/AST/Interp/Program.h 30 class Expr;
tools/clang/lib/CodeGen/CGOpenCLRuntime.h 27 class Expr;
tools/clang/lib/CodeGen/CGOpenMPRuntime.h 39 class Expr;
tools/clang/lib/CodeGen/CodeGenModule.h 64 class Expr;
tools/clang/lib/Index/IndexingContext.h 31 class Expr;
tools/clang/tools/libclang/CXCursor.h 28 class Expr;
tools/lldb/include/lldb/Core/ClangForward.h 55 class Expr;
References
gen/tools/clang/include/clang/AST/AttrVisitor.inc 1258 Expr * *I = A->args_begin();
1259 Expr * *E = A->args_end();
1275 Expr * *I = A->args_begin();
1276 Expr * *E = A->args_end();
1292 Expr * *I = A->args_begin();
1293 Expr * *E = A->args_end();
1489 Expr * *I = A->args_begin();
1490 Expr * *E = A->args_end();
1506 Expr * *I = A->args_begin();
1507 Expr * *E = A->args_end();
1523 Expr * *I = A->args_begin();
1524 Expr * *E = A->args_end();
1995 Expr * *I = A->args_begin();
1996 Expr * *E = A->args_end();
2244 Expr * *I = A->args_begin();
2245 Expr * *E = A->args_end();
2708 Expr * *I = A->uniforms_begin();
2709 Expr * *E = A->uniforms_end();
2716 Expr * *I = A->aligneds_begin();
2717 Expr * *E = A->aligneds_end();
2724 Expr * *I = A->alignments_begin();
2725 Expr * *E = A->alignments_end();
2732 Expr * *I = A->linears_begin();
2733 Expr * *E = A->linears_end();
2740 Expr * *I = A->steps_begin();
2741 Expr * *E = A->steps_end();
3401 Expr * *I = A->args_begin();
3402 Expr * *E = A->args_end();
3436 Expr * *I = A->args_begin();
3437 Expr * *E = A->args_end();
3545 Expr * *I = A->args_begin();
3546 Expr * *E = A->args_end();
3699 Expr * *I = A->args_begin();
3700 Expr * *E = A->args_end();
gen/tools/clang/include/clang/AST/Attrs.inc 53 Expr * min;
55 Expr * max;
58 static AMDGPUFlatWorkGroupSizeAttr *CreateImplicit(ASTContext &Ctx, Expr * Min, Expr * Max, const AttributeCommonInfo &CommonInfo = {SourceRange{}}) {
58 static AMDGPUFlatWorkGroupSizeAttr *CreateImplicit(ASTContext &Ctx, Expr * Min, Expr * Max, const AttributeCommonInfo &CommonInfo = {SourceRange{}}) {
66 static AMDGPUFlatWorkGroupSizeAttr *Create(ASTContext &Ctx, Expr * Min, Expr * Max, const AttributeCommonInfo &CommonInfo = {SourceRange{}}) {
66 static AMDGPUFlatWorkGroupSizeAttr *Create(ASTContext &Ctx, Expr * Min, Expr * Max, const AttributeCommonInfo &CommonInfo = {SourceRange{}}) {
73 static AMDGPUFlatWorkGroupSizeAttr *CreateImplicit(ASTContext &Ctx, Expr * Min, Expr * Max, SourceRange Range, AttributeCommonInfo::Syntax Syntax) {
73 static AMDGPUFlatWorkGroupSizeAttr *CreateImplicit(ASTContext &Ctx, Expr * Min, Expr * Max, SourceRange Range, AttributeCommonInfo::Syntax Syntax) {
77 static AMDGPUFlatWorkGroupSizeAttr *Create(ASTContext &Ctx, Expr * Min, Expr * Max, SourceRange Range, AttributeCommonInfo::Syntax Syntax) {
77 static AMDGPUFlatWorkGroupSizeAttr *Create(ASTContext &Ctx, Expr * Min, Expr * Max, SourceRange Range, AttributeCommonInfo::Syntax Syntax) {
82 , Expr * Min
83 , Expr * Max
95 Expr * getMin() const {
99 Expr * getMax() const {
205 Expr * min;
207 Expr * max;
210 static AMDGPUWavesPerEUAttr *CreateImplicit(ASTContext &Ctx, Expr * Min, Expr * Max, const AttributeCommonInfo &CommonInfo = {SourceRange{}}) {
210 static AMDGPUWavesPerEUAttr *CreateImplicit(ASTContext &Ctx, Expr * Min, Expr * Max, const AttributeCommonInfo &CommonInfo = {SourceRange{}}) {
218 static AMDGPUWavesPerEUAttr *Create(ASTContext &Ctx, Expr * Min, Expr * Max, const AttributeCommonInfo &CommonInfo = {SourceRange{}}) {
218 static AMDGPUWavesPerEUAttr *Create(ASTContext &Ctx, Expr * Min, Expr * Max, const AttributeCommonInfo &CommonInfo = {SourceRange{}}) {
225 static AMDGPUWavesPerEUAttr *CreateImplicit(ASTContext &Ctx, Expr * Min, Expr * Max, SourceRange Range, AttributeCommonInfo::Syntax Syntax) {
225 static AMDGPUWavesPerEUAttr *CreateImplicit(ASTContext &Ctx, Expr * Min, Expr * Max, SourceRange Range, AttributeCommonInfo::Syntax Syntax) {
229 static AMDGPUWavesPerEUAttr *Create(ASTContext &Ctx, Expr * Min, Expr * Max, SourceRange Range, AttributeCommonInfo::Syntax Syntax) {
229 static AMDGPUWavesPerEUAttr *Create(ASTContext &Ctx, Expr * Min, Expr * Max, SourceRange Range, AttributeCommonInfo::Syntax Syntax) {
234 , Expr * Min
235 , Expr * Max
244 , Expr * Min
256 Expr * getMin() const {
260 Expr * getMax() const {
511 Expr * *args_;
525 static AcquireCapabilityAttr *CreateImplicit(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, const AttributeCommonInfo &CommonInfo = {SourceRange{}}) {
533 static AcquireCapabilityAttr *Create(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, const AttributeCommonInfo &CommonInfo = {SourceRange{}}) {
538 static AcquireCapabilityAttr *CreateImplicit(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, SourceRange Range, AttributeCommonInfo::Syntax Syntax, AcquireCapabilityAttr::Spelling S = static_cast<Spelling>(SpellingNotCalculated)) {
542 static AcquireCapabilityAttr *Create(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, SourceRange Range, AttributeCommonInfo::Syntax Syntax, AcquireCapabilityAttr::Spelling S = static_cast<Spelling>(SpellingNotCalculated)) {
547 , Expr * *Args, unsigned ArgsSize
550 , args_Size(ArgsSize), args_(new (Ctx, 16) Expr *[args_Size])
580 typedef Expr ** args_iterator;
594 Expr * *args_;
597 static AcquiredAfterAttr *CreateImplicit(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, const AttributeCommonInfo &CommonInfo = {SourceRange{}}) {
605 static AcquiredAfterAttr *Create(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, const AttributeCommonInfo &CommonInfo = {SourceRange{}}) {
612 static AcquiredAfterAttr *CreateImplicit(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, SourceRange Range, AttributeCommonInfo::Syntax Syntax) {
616 static AcquiredAfterAttr *Create(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, SourceRange Range, AttributeCommonInfo::Syntax Syntax) {
621 , Expr * *Args, unsigned ArgsSize
624 , args_Size(ArgsSize), args_(new (Ctx, 16) Expr *[args_Size])
640 typedef Expr ** args_iterator;
654 Expr * *args_;
657 static AcquiredBeforeAttr *CreateImplicit(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, const AttributeCommonInfo &CommonInfo = {SourceRange{}}) {
665 static AcquiredBeforeAttr *Create(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, const AttributeCommonInfo &CommonInfo = {SourceRange{}}) {
672 static AcquiredBeforeAttr *CreateImplicit(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, SourceRange Range, AttributeCommonInfo::Syntax Syntax) {
676 static AcquiredBeforeAttr *Create(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, SourceRange Range, AttributeCommonInfo::Syntax Syntax) {
681 , Expr * *Args, unsigned ArgsSize
684 , args_Size(ArgsSize), args_(new (Ctx, 16) Expr *[args_Size])
700 typedef Expr ** args_iterator;
861 Expr * alignment;
864 static AlignValueAttr *CreateImplicit(ASTContext &Ctx, Expr * Alignment, const AttributeCommonInfo &CommonInfo = {SourceRange{}}) {
872 static AlignValueAttr *Create(ASTContext &Ctx, Expr * Alignment, const AttributeCommonInfo &CommonInfo = {SourceRange{}}) {
879 static AlignValueAttr *CreateImplicit(ASTContext &Ctx, Expr * Alignment, SourceRange Range, AttributeCommonInfo::Syntax Syntax) {
883 static AlignValueAttr *Create(ASTContext &Ctx, Expr * Alignment, SourceRange Range, AttributeCommonInfo::Syntax Syntax) {
888 , Expr * Alignment
899 Expr * getAlignment() const {
911 Expr *alignmentExpr;
991 Expr *getAlignmentExpr() const {
1794 Expr * *args_;
1806 static AssertCapabilityAttr *CreateImplicit(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, const AttributeCommonInfo &CommonInfo = {SourceRange{}}) {
1814 static AssertCapabilityAttr *Create(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, const AttributeCommonInfo &CommonInfo = {SourceRange{}}) {
1819 static AssertCapabilityAttr *CreateImplicit(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, SourceRange Range, AttributeCommonInfo::Syntax Syntax, AssertCapabilityAttr::Spelling S = static_cast<Spelling>(SpellingNotCalculated)) {
1823 static AssertCapabilityAttr *Create(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, SourceRange Range, AttributeCommonInfo::Syntax Syntax, AssertCapabilityAttr::Spelling S = static_cast<Spelling>(SpellingNotCalculated)) {
1828 , Expr * *Args, unsigned ArgsSize
1831 , args_Size(ArgsSize), args_(new (Ctx, 16) Expr *[args_Size])
1858 typedef Expr ** args_iterator;
1872 Expr * *args_;
1875 static AssertExclusiveLockAttr *CreateImplicit(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, const AttributeCommonInfo &CommonInfo = {SourceRange{}}) {
1883 static AssertExclusiveLockAttr *Create(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, const AttributeCommonInfo &CommonInfo = {SourceRange{}}) {
1890 static AssertExclusiveLockAttr *CreateImplicit(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, SourceRange Range, AttributeCommonInfo::Syntax Syntax) {
1894 static AssertExclusiveLockAttr *Create(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, SourceRange Range, AttributeCommonInfo::Syntax Syntax) {
1899 , Expr * *Args, unsigned ArgsSize
1902 , args_Size(ArgsSize), args_(new (Ctx, 16) Expr *[args_Size])
1918 typedef Expr ** args_iterator;
1932 Expr * *args_;
1935 static AssertSharedLockAttr *CreateImplicit(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, const AttributeCommonInfo &CommonInfo = {SourceRange{}}) {
1943 static AssertSharedLockAttr *Create(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, const AttributeCommonInfo &CommonInfo = {SourceRange{}}) {
1950 static AssertSharedLockAttr *CreateImplicit(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, SourceRange Range, AttributeCommonInfo::Syntax Syntax) {
1954 static AssertSharedLockAttr *Create(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, SourceRange Range, AttributeCommonInfo::Syntax Syntax) {
1959 , Expr * *Args, unsigned ArgsSize
1962 , args_Size(ArgsSize), args_(new (Ctx, 16) Expr *[args_Size])
1978 typedef Expr ** args_iterator;
1991 Expr * alignment;
1993 Expr * offset;
1996 static AssumeAlignedAttr *CreateImplicit(ASTContext &Ctx, Expr * Alignment, Expr * Offset, const AttributeCommonInfo &CommonInfo = {SourceRange{}}) {
1996 static AssumeAlignedAttr *CreateImplicit(ASTContext &Ctx, Expr * Alignment, Expr * Offset, const AttributeCommonInfo &CommonInfo = {SourceRange{}}) {
2004 static AssumeAlignedAttr *Create(ASTContext &Ctx, Expr * Alignment, Expr * Offset, const AttributeCommonInfo &CommonInfo = {SourceRange{}}) {
2004 static AssumeAlignedAttr *Create(ASTContext &Ctx, Expr * Alignment, Expr * Offset, const AttributeCommonInfo &CommonInfo = {SourceRange{}}) {
2011 static AssumeAlignedAttr *CreateImplicit(ASTContext &Ctx, Expr * Alignment, Expr * Offset, SourceRange Range, AttributeCommonInfo::Syntax Syntax) {
2011 static AssumeAlignedAttr *CreateImplicit(ASTContext &Ctx, Expr * Alignment, Expr * Offset, SourceRange Range, AttributeCommonInfo::Syntax Syntax) {
2015 static AssumeAlignedAttr *Create(ASTContext &Ctx, Expr * Alignment, Expr * Offset, SourceRange Range, AttributeCommonInfo::Syntax Syntax) {
2015 static AssumeAlignedAttr *Create(ASTContext &Ctx, Expr * Alignment, Expr * Offset, SourceRange Range, AttributeCommonInfo::Syntax Syntax) {
2020 , Expr * Alignment
2021 , Expr * Offset
2030 , Expr * Alignment
2042 Expr * getAlignment() const {
2046 Expr * getOffset() const {
2955 Expr * maxThreads;
2957 Expr * minBlocks;
2960 static CUDALaunchBoundsAttr *CreateImplicit(ASTContext &Ctx, Expr * MaxThreads, Expr * MinBlocks, const AttributeCommonInfo &CommonInfo = {SourceRange{}}) {
2960 static CUDALaunchBoundsAttr *CreateImplicit(ASTContext &Ctx, Expr * MaxThreads, Expr * MinBlocks, const AttributeCommonInfo &CommonInfo = {SourceRange{}}) {
2968 static CUDALaunchBoundsAttr *Create(ASTContext &Ctx, Expr * MaxThreads, Expr * MinBlocks, const AttributeCommonInfo &CommonInfo = {SourceRange{}}) {
2968 static CUDALaunchBoundsAttr *Create(ASTContext &Ctx, Expr * MaxThreads, Expr * MinBlocks, const AttributeCommonInfo &CommonInfo = {SourceRange{}}) {
2975 static CUDALaunchBoundsAttr *CreateImplicit(ASTContext &Ctx, Expr * MaxThreads, Expr * MinBlocks, SourceRange Range, AttributeCommonInfo::Syntax Syntax) {
2975 static CUDALaunchBoundsAttr *CreateImplicit(ASTContext &Ctx, Expr * MaxThreads, Expr * MinBlocks, SourceRange Range, AttributeCommonInfo::Syntax Syntax) {
2979 static CUDALaunchBoundsAttr *Create(ASTContext &Ctx, Expr * MaxThreads, Expr * MinBlocks, SourceRange Range, AttributeCommonInfo::Syntax Syntax) {
2979 static CUDALaunchBoundsAttr *Create(ASTContext &Ctx, Expr * MaxThreads, Expr * MinBlocks, SourceRange Range, AttributeCommonInfo::Syntax Syntax) {
2984 , Expr * MaxThreads
2985 , Expr * MinBlocks
2994 , Expr * MaxThreads
3006 Expr * getMaxThreads() const {
3010 Expr * getMinBlocks() const {
4257 Expr * cond;
4275 static DiagnoseIfAttr *CreateImplicit(ASTContext &Ctx, Expr * Cond, llvm::StringRef Message, DiagnosticType DiagnosticType, bool ArgDependent, NamedDecl * Parent, const AttributeCommonInfo &CommonInfo = {SourceRange{}}) {
4283 static DiagnoseIfAttr *Create(ASTContext &Ctx, Expr * Cond, llvm::StringRef Message, DiagnosticType DiagnosticType, bool ArgDependent, NamedDecl * Parent, const AttributeCommonInfo &CommonInfo = {SourceRange{}}) {
4290 static DiagnoseIfAttr *CreateImplicit(ASTContext &Ctx, Expr * Cond, llvm::StringRef Message, DiagnosticType DiagnosticType, bool ArgDependent, NamedDecl * Parent, SourceRange Range, AttributeCommonInfo::Syntax Syntax) {
4294 static DiagnoseIfAttr *Create(ASTContext &Ctx, Expr * Cond, llvm::StringRef Message, DiagnosticType DiagnosticType, bool ArgDependent, NamedDecl * Parent, SourceRange Range, AttributeCommonInfo::Syntax Syntax) {
4298 static DiagnoseIfAttr *CreateImplicit(ASTContext &Ctx, Expr * Cond, llvm::StringRef Message, DiagnosticType DiagnosticType, const AttributeCommonInfo &CommonInfo = {SourceRange{}}) {
4306 static DiagnoseIfAttr *Create(ASTContext &Ctx, Expr * Cond, llvm::StringRef Message, DiagnosticType DiagnosticType, const AttributeCommonInfo &CommonInfo = {SourceRange{}}) {
4313 static DiagnoseIfAttr *CreateImplicit(ASTContext &Ctx, Expr * Cond, llvm::StringRef Message, DiagnosticType DiagnosticType, SourceRange Range, AttributeCommonInfo::Syntax Syntax) {
4317 static DiagnoseIfAttr *Create(ASTContext &Ctx, Expr * Cond, llvm::StringRef Message, DiagnosticType DiagnosticType, SourceRange Range, AttributeCommonInfo::Syntax Syntax) {
4322 , Expr * Cond
4340 , Expr * Cond
4359 Expr * getCond() const {
4496 Expr * cond;
4502 static EnableIfAttr *CreateImplicit(ASTContext &Ctx, Expr * Cond, llvm::StringRef Message, const AttributeCommonInfo &CommonInfo = {SourceRange{}}) {
4510 static EnableIfAttr *Create(ASTContext &Ctx, Expr * Cond, llvm::StringRef Message, const AttributeCommonInfo &CommonInfo = {SourceRange{}}) {
4517 static EnableIfAttr *CreateImplicit(ASTContext &Ctx, Expr * Cond, llvm::StringRef Message, SourceRange Range, AttributeCommonInfo::Syntax Syntax) {
4521 static EnableIfAttr *Create(ASTContext &Ctx, Expr * Cond, llvm::StringRef Message, SourceRange Range, AttributeCommonInfo::Syntax Syntax) {
4526 , Expr * Cond
4541 Expr * getCond() const {
4677 Expr * successValue;
4680 Expr * *args_;
4683 static ExclusiveTrylockFunctionAttr *CreateImplicit(ASTContext &Ctx, Expr * SuccessValue, Expr * *Args, unsigned ArgsSize, const AttributeCommonInfo &CommonInfo = {SourceRange{}}) {
4683 static ExclusiveTrylockFunctionAttr *CreateImplicit(ASTContext &Ctx, Expr * SuccessValue, Expr * *Args, unsigned ArgsSize, const AttributeCommonInfo &CommonInfo = {SourceRange{}}) {
4691 static ExclusiveTrylockFunctionAttr *Create(ASTContext &Ctx, Expr * SuccessValue, Expr * *Args, unsigned ArgsSize, const AttributeCommonInfo &CommonInfo = {SourceRange{}}) {
4691 static ExclusiveTrylockFunctionAttr *Create(ASTContext &Ctx, Expr * SuccessValue, Expr * *Args, unsigned ArgsSize, const AttributeCommonInfo &CommonInfo = {SourceRange{}}) {
4698 static ExclusiveTrylockFunctionAttr *CreateImplicit(ASTContext &Ctx, Expr * SuccessValue, Expr * *Args, unsigned ArgsSize, SourceRange Range, AttributeCommonInfo::Syntax Syntax) {
4698 static ExclusiveTrylockFunctionAttr *CreateImplicit(ASTContext &Ctx, Expr * SuccessValue, Expr * *Args, unsigned ArgsSize, SourceRange Range, AttributeCommonInfo::Syntax Syntax) {
4702 static ExclusiveTrylockFunctionAttr *Create(ASTContext &Ctx, Expr * SuccessValue, Expr * *Args, unsigned ArgsSize, SourceRange Range, AttributeCommonInfo::Syntax Syntax) {
4702 static ExclusiveTrylockFunctionAttr *Create(ASTContext &Ctx, Expr * SuccessValue, Expr * *Args, unsigned ArgsSize, SourceRange Range, AttributeCommonInfo::Syntax Syntax) {
4707 , Expr * SuccessValue
4708 , Expr * *Args, unsigned ArgsSize
4712 , args_Size(ArgsSize), args_(new (Ctx, 16) Expr *[args_Size])
4718 , Expr * SuccessValue
4730 Expr * getSuccessValue() const {
4734 typedef Expr ** args_iterator;
5209 Expr * arg;
5212 static GuardedByAttr *CreateImplicit(ASTContext &Ctx, Expr * Arg, const AttributeCommonInfo &CommonInfo = {SourceRange{}}) {
5220 static GuardedByAttr *Create(ASTContext &Ctx, Expr * Arg, const AttributeCommonInfo &CommonInfo = {SourceRange{}}) {
5227 static GuardedByAttr *CreateImplicit(ASTContext &Ctx, Expr * Arg, SourceRange Range, AttributeCommonInfo::Syntax Syntax) {
5231 static GuardedByAttr *Create(ASTContext &Ctx, Expr * Arg, SourceRange Range, AttributeCommonInfo::Syntax Syntax) {
5236 , Expr * Arg
5247 Expr * getArg() const {
5894 Expr * arg;
5897 static LockReturnedAttr *CreateImplicit(ASTContext &Ctx, Expr * Arg, const AttributeCommonInfo &CommonInfo = {SourceRange{}}) {
5905 static LockReturnedAttr *Create(ASTContext &Ctx, Expr * Arg, const AttributeCommonInfo &CommonInfo = {SourceRange{}}) {
5912 static LockReturnedAttr *CreateImplicit(ASTContext &Ctx, Expr * Arg, SourceRange Range, AttributeCommonInfo::Syntax Syntax) {
5916 static LockReturnedAttr *Create(ASTContext &Ctx, Expr * Arg, SourceRange Range, AttributeCommonInfo::Syntax Syntax) {
5921 , Expr * Arg
5932 Expr * getArg() const {
5943 Expr * *args_;
5946 static LocksExcludedAttr *CreateImplicit(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, const AttributeCommonInfo &CommonInfo = {SourceRange{}}) {
5954 static LocksExcludedAttr *Create(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, const AttributeCommonInfo &CommonInfo = {SourceRange{}}) {
5961 static LocksExcludedAttr *CreateImplicit(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, SourceRange Range, AttributeCommonInfo::Syntax Syntax) {
5965 static LocksExcludedAttr *Create(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, SourceRange Range, AttributeCommonInfo::Syntax Syntax) {
5970 , Expr * *Args, unsigned ArgsSize
5973 , args_Size(ArgsSize), args_(new (Ctx, 16) Expr *[args_Size])
5989 typedef Expr ** args_iterator;
6031 Expr * value;
6044 static LoopHintAttr *CreateImplicit(ASTContext &Ctx, OptionType Option, LoopHintState State, Expr * Value, const AttributeCommonInfo &CommonInfo = {SourceRange{}}) {
6052 static LoopHintAttr *Create(ASTContext &Ctx, OptionType Option, LoopHintState State, Expr * Value, const AttributeCommonInfo &CommonInfo = {SourceRange{}}) {
6057 static LoopHintAttr *CreateImplicit(ASTContext &Ctx, OptionType Option, LoopHintState State, Expr * Value, SourceRange Range, AttributeCommonInfo::Syntax Syntax, LoopHintAttr::Spelling S = static_cast<Spelling>(SpellingNotCalculated)) {
6061 static LoopHintAttr *Create(ASTContext &Ctx, OptionType Option, LoopHintState State, Expr * Value, SourceRange Range, AttributeCommonInfo::Syntax Syntax, LoopHintAttr::Spelling S = static_cast<Spelling>(SpellingNotCalculated)) {
6068 , Expr * Value
6163 Expr * getValue() const {
8334 Expr * allocator;
8337 static OMPAllocateDeclAttr *CreateImplicit(ASTContext &Ctx, AllocatorTypeTy AllocatorType, Expr * Allocator, const AttributeCommonInfo &CommonInfo = {SourceRange{}}) {
8345 static OMPAllocateDeclAttr *Create(ASTContext &Ctx, AllocatorTypeTy AllocatorType, Expr * Allocator, const AttributeCommonInfo &CommonInfo = {SourceRange{}}) {
8352 static OMPAllocateDeclAttr *CreateImplicit(ASTContext &Ctx, AllocatorTypeTy AllocatorType, Expr * Allocator, SourceRange Range, AttributeCommonInfo::Syntax Syntax) {
8356 static OMPAllocateDeclAttr *Create(ASTContext &Ctx, AllocatorTypeTy AllocatorType, Expr * Allocator, SourceRange Range, AttributeCommonInfo::Syntax Syntax) {
8362 , Expr * Allocator
8411 Expr * getAllocator() const {
8518 Expr * simdlen;
8521 Expr * *uniforms_;
8524 Expr * *aligneds_;
8527 Expr * *alignments_;
8530 Expr * *linears_;
8536 Expr * *steps_;
8539 static OMPDeclareSimdDeclAttr *CreateImplicit(ASTContext &Ctx, BranchStateTy BranchState, Expr * Simdlen, Expr * *Uniforms, unsigned UniformsSize, Expr * *Aligneds, unsigned AlignedsSize, Expr * *Alignments, unsigned AlignmentsSize, Expr * *Linears, unsigned LinearsSize, unsigned *Modifiers, unsigned ModifiersSize, Expr * *Steps, unsigned StepsSize, const AttributeCommonInfo &CommonInfo = {SourceRange{}}) {
8539 static OMPDeclareSimdDeclAttr *CreateImplicit(ASTContext &Ctx, BranchStateTy BranchState, Expr * Simdlen, Expr * *Uniforms, unsigned UniformsSize, Expr * *Aligneds, unsigned AlignedsSize, Expr * *Alignments, unsigned AlignmentsSize, Expr * *Linears, unsigned LinearsSize, unsigned *Modifiers, unsigned ModifiersSize, Expr * *Steps, unsigned StepsSize, const AttributeCommonInfo &CommonInfo = {SourceRange{}}) {
8539 static OMPDeclareSimdDeclAttr *CreateImplicit(ASTContext &Ctx, BranchStateTy BranchState, Expr * Simdlen, Expr * *Uniforms, unsigned UniformsSize, Expr * *Aligneds, unsigned AlignedsSize, Expr * *Alignments, unsigned AlignmentsSize, Expr * *Linears, unsigned LinearsSize, unsigned *Modifiers, unsigned ModifiersSize, Expr * *Steps, unsigned StepsSize, const AttributeCommonInfo &CommonInfo = {SourceRange{}}) {
8539 static OMPDeclareSimdDeclAttr *CreateImplicit(ASTContext &Ctx, BranchStateTy BranchState, Expr * Simdlen, Expr * *Uniforms, unsigned UniformsSize, Expr * *Aligneds, unsigned AlignedsSize, Expr * *Alignments, unsigned AlignmentsSize, Expr * *Linears, unsigned LinearsSize, unsigned *Modifiers, unsigned ModifiersSize, Expr * *Steps, unsigned StepsSize, const AttributeCommonInfo &CommonInfo = {SourceRange{}}) {
8539 static OMPDeclareSimdDeclAttr *CreateImplicit(ASTContext &Ctx, BranchStateTy BranchState, Expr * Simdlen, Expr * *Uniforms, unsigned UniformsSize, Expr * *Aligneds, unsigned AlignedsSize, Expr * *Alignments, unsigned AlignmentsSize, Expr * *Linears, unsigned LinearsSize, unsigned *Modifiers, unsigned ModifiersSize, Expr * *Steps, unsigned StepsSize, const AttributeCommonInfo &CommonInfo = {SourceRange{}}) {
8539 static OMPDeclareSimdDeclAttr *CreateImplicit(ASTContext &Ctx, BranchStateTy BranchState, Expr * Simdlen, Expr * *Uniforms, unsigned UniformsSize, Expr * *Aligneds, unsigned AlignedsSize, Expr * *Alignments, unsigned AlignmentsSize, Expr * *Linears, unsigned LinearsSize, unsigned *Modifiers, unsigned ModifiersSize, Expr * *Steps, unsigned StepsSize, const AttributeCommonInfo &CommonInfo = {SourceRange{}}) {
8547 static OMPDeclareSimdDeclAttr *Create(ASTContext &Ctx, BranchStateTy BranchState, Expr * Simdlen, Expr * *Uniforms, unsigned UniformsSize, Expr * *Aligneds, unsigned AlignedsSize, Expr * *Alignments, unsigned AlignmentsSize, Expr * *Linears, unsigned LinearsSize, unsigned *Modifiers, unsigned ModifiersSize, Expr * *Steps, unsigned StepsSize, const AttributeCommonInfo &CommonInfo = {SourceRange{}}) {
8547 static OMPDeclareSimdDeclAttr *Create(ASTContext &Ctx, BranchStateTy BranchState, Expr * Simdlen, Expr * *Uniforms, unsigned UniformsSize, Expr * *Aligneds, unsigned AlignedsSize, Expr * *Alignments, unsigned AlignmentsSize, Expr * *Linears, unsigned LinearsSize, unsigned *Modifiers, unsigned ModifiersSize, Expr * *Steps, unsigned StepsSize, const AttributeCommonInfo &CommonInfo = {SourceRange{}}) {
8547 static OMPDeclareSimdDeclAttr *Create(ASTContext &Ctx, BranchStateTy BranchState, Expr * Simdlen, Expr * *Uniforms, unsigned UniformsSize, Expr * *Aligneds, unsigned AlignedsSize, Expr * *Alignments, unsigned AlignmentsSize, Expr * *Linears, unsigned LinearsSize, unsigned *Modifiers, unsigned ModifiersSize, Expr * *Steps, unsigned StepsSize, const AttributeCommonInfo &CommonInfo = {SourceRange{}}) {
8547 static OMPDeclareSimdDeclAttr *Create(ASTContext &Ctx, BranchStateTy BranchState, Expr * Simdlen, Expr * *Uniforms, unsigned UniformsSize, Expr * *Aligneds, unsigned AlignedsSize, Expr * *Alignments, unsigned AlignmentsSize, Expr * *Linears, unsigned LinearsSize, unsigned *Modifiers, unsigned ModifiersSize, Expr * *Steps, unsigned StepsSize, const AttributeCommonInfo &CommonInfo = {SourceRange{}}) {
8547 static OMPDeclareSimdDeclAttr *Create(ASTContext &Ctx, BranchStateTy BranchState, Expr * Simdlen, Expr * *Uniforms, unsigned UniformsSize, Expr * *Aligneds, unsigned AlignedsSize, Expr * *Alignments, unsigned AlignmentsSize, Expr * *Linears, unsigned LinearsSize, unsigned *Modifiers, unsigned ModifiersSize, Expr * *Steps, unsigned StepsSize, const AttributeCommonInfo &CommonInfo = {SourceRange{}}) {
8547 static OMPDeclareSimdDeclAttr *Create(ASTContext &Ctx, BranchStateTy BranchState, Expr * Simdlen, Expr * *Uniforms, unsigned UniformsSize, Expr * *Aligneds, unsigned AlignedsSize, Expr * *Alignments, unsigned AlignmentsSize, Expr * *Linears, unsigned LinearsSize, unsigned *Modifiers, unsigned ModifiersSize, Expr * *Steps, unsigned StepsSize, const AttributeCommonInfo &CommonInfo = {SourceRange{}}) {
8554 static OMPDeclareSimdDeclAttr *CreateImplicit(ASTContext &Ctx, BranchStateTy BranchState, Expr * Simdlen, Expr * *Uniforms, unsigned UniformsSize, Expr * *Aligneds, unsigned AlignedsSize, Expr * *Alignments, unsigned AlignmentsSize, Expr * *Linears, unsigned LinearsSize, unsigned *Modifiers, unsigned ModifiersSize, Expr * *Steps, unsigned StepsSize, SourceRange Range, AttributeCommonInfo::Syntax Syntax) {
8554 static OMPDeclareSimdDeclAttr *CreateImplicit(ASTContext &Ctx, BranchStateTy BranchState, Expr * Simdlen, Expr * *Uniforms, unsigned UniformsSize, Expr * *Aligneds, unsigned AlignedsSize, Expr * *Alignments, unsigned AlignmentsSize, Expr * *Linears, unsigned LinearsSize, unsigned *Modifiers, unsigned ModifiersSize, Expr * *Steps, unsigned StepsSize, SourceRange Range, AttributeCommonInfo::Syntax Syntax) {
8554 static OMPDeclareSimdDeclAttr *CreateImplicit(ASTContext &Ctx, BranchStateTy BranchState, Expr * Simdlen, Expr * *Uniforms, unsigned UniformsSize, Expr * *Aligneds, unsigned AlignedsSize, Expr * *Alignments, unsigned AlignmentsSize, Expr * *Linears, unsigned LinearsSize, unsigned *Modifiers, unsigned ModifiersSize, Expr * *Steps, unsigned StepsSize, SourceRange Range, AttributeCommonInfo::Syntax Syntax) {
8554 static OMPDeclareSimdDeclAttr *CreateImplicit(ASTContext &Ctx, BranchStateTy BranchState, Expr * Simdlen, Expr * *Uniforms, unsigned UniformsSize, Expr * *Aligneds, unsigned AlignedsSize, Expr * *Alignments, unsigned AlignmentsSize, Expr * *Linears, unsigned LinearsSize, unsigned *Modifiers, unsigned ModifiersSize, Expr * *Steps, unsigned StepsSize, SourceRange Range, AttributeCommonInfo::Syntax Syntax) {
8554 static OMPDeclareSimdDeclAttr *CreateImplicit(ASTContext &Ctx, BranchStateTy BranchState, Expr * Simdlen, Expr * *Uniforms, unsigned UniformsSize, Expr * *Aligneds, unsigned AlignedsSize, Expr * *Alignments, unsigned AlignmentsSize, Expr * *Linears, unsigned LinearsSize, unsigned *Modifiers, unsigned ModifiersSize, Expr * *Steps, unsigned StepsSize, SourceRange Range, AttributeCommonInfo::Syntax Syntax) {
8554 static OMPDeclareSimdDeclAttr *CreateImplicit(ASTContext &Ctx, BranchStateTy BranchState, Expr * Simdlen, Expr * *Uniforms, unsigned UniformsSize, Expr * *Aligneds, unsigned AlignedsSize, Expr * *Alignments, unsigned AlignmentsSize, Expr * *Linears, unsigned LinearsSize, unsigned *Modifiers, unsigned ModifiersSize, Expr * *Steps, unsigned StepsSize, SourceRange Range, AttributeCommonInfo::Syntax Syntax) {
8558 static OMPDeclareSimdDeclAttr *Create(ASTContext &Ctx, BranchStateTy BranchState, Expr * Simdlen, Expr * *Uniforms, unsigned UniformsSize, Expr * *Aligneds, unsigned AlignedsSize, Expr * *Alignments, unsigned AlignmentsSize, Expr * *Linears, unsigned LinearsSize, unsigned *Modifiers, unsigned ModifiersSize, Expr * *Steps, unsigned StepsSize, SourceRange Range, AttributeCommonInfo::Syntax Syntax) {
8558 static OMPDeclareSimdDeclAttr *Create(ASTContext &Ctx, BranchStateTy BranchState, Expr * Simdlen, Expr * *Uniforms, unsigned UniformsSize, Expr * *Aligneds, unsigned AlignedsSize, Expr * *Alignments, unsigned AlignmentsSize, Expr * *Linears, unsigned LinearsSize, unsigned *Modifiers, unsigned ModifiersSize, Expr * *Steps, unsigned StepsSize, SourceRange Range, AttributeCommonInfo::Syntax Syntax) {
8558 static OMPDeclareSimdDeclAttr *Create(ASTContext &Ctx, BranchStateTy BranchState, Expr * Simdlen, Expr * *Uniforms, unsigned UniformsSize, Expr * *Aligneds, unsigned AlignedsSize, Expr * *Alignments, unsigned AlignmentsSize, Expr * *Linears, unsigned LinearsSize, unsigned *Modifiers, unsigned ModifiersSize, Expr * *Steps, unsigned StepsSize, SourceRange Range, AttributeCommonInfo::Syntax Syntax) {
8558 static OMPDeclareSimdDeclAttr *Create(ASTContext &Ctx, BranchStateTy BranchState, Expr * Simdlen, Expr * *Uniforms, unsigned UniformsSize, Expr * *Aligneds, unsigned AlignedsSize, Expr * *Alignments, unsigned AlignmentsSize, Expr * *Linears, unsigned LinearsSize, unsigned *Modifiers, unsigned ModifiersSize, Expr * *Steps, unsigned StepsSize, SourceRange Range, AttributeCommonInfo::Syntax Syntax) {
8558 static OMPDeclareSimdDeclAttr *Create(ASTContext &Ctx, BranchStateTy BranchState, Expr * Simdlen, Expr * *Uniforms, unsigned UniformsSize, Expr * *Aligneds, unsigned AlignedsSize, Expr * *Alignments, unsigned AlignmentsSize, Expr * *Linears, unsigned LinearsSize, unsigned *Modifiers, unsigned ModifiersSize, Expr * *Steps, unsigned StepsSize, SourceRange Range, AttributeCommonInfo::Syntax Syntax) {
8558 static OMPDeclareSimdDeclAttr *Create(ASTContext &Ctx, BranchStateTy BranchState, Expr * Simdlen, Expr * *Uniforms, unsigned UniformsSize, Expr * *Aligneds, unsigned AlignedsSize, Expr * *Alignments, unsigned AlignmentsSize, Expr * *Linears, unsigned LinearsSize, unsigned *Modifiers, unsigned ModifiersSize, Expr * *Steps, unsigned StepsSize, SourceRange Range, AttributeCommonInfo::Syntax Syntax) {
8564 , Expr * Simdlen
8565 , Expr * *Uniforms, unsigned UniformsSize
8566 , Expr * *Aligneds, unsigned AlignedsSize
8567 , Expr * *Alignments, unsigned AlignmentsSize
8568 , Expr * *Linears, unsigned LinearsSize
8570 , Expr * *Steps, unsigned StepsSize
8575 , uniforms_Size(UniformsSize), uniforms_(new (Ctx, 16) Expr *[uniforms_Size])
8576 , aligneds_Size(AlignedsSize), aligneds_(new (Ctx, 16) Expr *[aligneds_Size])
8577 , alignments_Size(AlignmentsSize), alignments_(new (Ctx, 16) Expr *[alignments_Size])
8578 , linears_Size(LinearsSize), linears_(new (Ctx, 16) Expr *[linears_Size])
8580 , steps_Size(StepsSize), steps_(new (Ctx, 16) Expr *[steps_Size])
8592 , Expr * Simdlen
8635 Expr * getSimdlen() const {
8639 typedef Expr ** uniforms_iterator;
8646 typedef Expr ** aligneds_iterator;
8653 typedef Expr ** alignments_iterator;
8660 typedef Expr ** linears_iterator;
8674 typedef Expr ** steps_iterator;
8686 if (auto *E = getSimdlen()) {
8694 for (auto *E : uniforms()) {
8702 for (auto *E : aligneds()) {
8714 for (auto *E : linears()) {
8870 Expr * variantFuncRef;
8872 Expr * score;
8902 static OMPDeclareVariantAttr *CreateImplicit(ASTContext &Ctx, Expr * VariantFuncRef, Expr * Score, CtxSelectorSetType CtxSelectorSet, ScoreType CtxScore, CtxSelectorType CtxSelector, StringRef *ImplVendors, unsigned ImplVendorsSize, const AttributeCommonInfo &CommonInfo = {SourceRange{}}) {
8902 static OMPDeclareVariantAttr *CreateImplicit(ASTContext &Ctx, Expr * VariantFuncRef, Expr * Score, CtxSelectorSetType CtxSelectorSet, ScoreType CtxScore, CtxSelectorType CtxSelector, StringRef *ImplVendors, unsigned ImplVendorsSize, const AttributeCommonInfo &CommonInfo = {SourceRange{}}) {
8910 static OMPDeclareVariantAttr *Create(ASTContext &Ctx, Expr * VariantFuncRef, Expr * Score, CtxSelectorSetType CtxSelectorSet, ScoreType CtxScore, CtxSelectorType CtxSelector, StringRef *ImplVendors, unsigned ImplVendorsSize, const AttributeCommonInfo &CommonInfo = {SourceRange{}}) {
8910 static OMPDeclareVariantAttr *Create(ASTContext &Ctx, Expr * VariantFuncRef, Expr * Score, CtxSelectorSetType CtxSelectorSet, ScoreType CtxScore, CtxSelectorType CtxSelector, StringRef *ImplVendors, unsigned ImplVendorsSize, const AttributeCommonInfo &CommonInfo = {SourceRange{}}) {
8917 static OMPDeclareVariantAttr *CreateImplicit(ASTContext &Ctx, Expr * VariantFuncRef, Expr * Score, CtxSelectorSetType CtxSelectorSet, ScoreType CtxScore, CtxSelectorType CtxSelector, StringRef *ImplVendors, unsigned ImplVendorsSize, SourceRange Range, AttributeCommonInfo::Syntax Syntax) {
8917 static OMPDeclareVariantAttr *CreateImplicit(ASTContext &Ctx, Expr * VariantFuncRef, Expr * Score, CtxSelectorSetType CtxSelectorSet, ScoreType CtxScore, CtxSelectorType CtxSelector, StringRef *ImplVendors, unsigned ImplVendorsSize, SourceRange Range, AttributeCommonInfo::Syntax Syntax) {
8921 static OMPDeclareVariantAttr *Create(ASTContext &Ctx, Expr * VariantFuncRef, Expr * Score, CtxSelectorSetType CtxSelectorSet, ScoreType CtxScore, CtxSelectorType CtxSelector, StringRef *ImplVendors, unsigned ImplVendorsSize, SourceRange Range, AttributeCommonInfo::Syntax Syntax) {
8921 static OMPDeclareVariantAttr *Create(ASTContext &Ctx, Expr * VariantFuncRef, Expr * Score, CtxSelectorSetType CtxSelectorSet, ScoreType CtxScore, CtxSelectorType CtxSelector, StringRef *ImplVendors, unsigned ImplVendorsSize, SourceRange Range, AttributeCommonInfo::Syntax Syntax) {
8926 , Expr * VariantFuncRef
8927 , Expr * Score
8953 , Expr * VariantFuncRef
8954 , Expr * Score
8973 Expr * getVariantFuncRef() const {
8977 Expr * getScore() const {
9059 if (const Expr *E = getScore()) {
9069 if (const Expr *E = getVariantFuncRef()) {
9106 Expr * ref;
9109 static OMPReferencedVarAttr *CreateImplicit(ASTContext &Ctx, Expr * Ref, const AttributeCommonInfo &CommonInfo = {SourceRange{}}) {
9117 static OMPReferencedVarAttr *Create(ASTContext &Ctx, Expr * Ref, const AttributeCommonInfo &CommonInfo = {SourceRange{}}) {
9124 static OMPReferencedVarAttr *CreateImplicit(ASTContext &Ctx, Expr * Ref, SourceRange Range, AttributeCommonInfo::Syntax Syntax) {
9128 static OMPReferencedVarAttr *Create(ASTContext &Ctx, Expr * Ref, SourceRange Range, AttributeCommonInfo::Syntax Syntax) {
9133 , Expr * Ref
9144 Expr * getRef() const {
11980 Expr * arg;
11983 static PtGuardedByAttr *CreateImplicit(ASTContext &Ctx, Expr * Arg, const AttributeCommonInfo &CommonInfo = {SourceRange{}}) {
11991 static PtGuardedByAttr *Create(ASTContext &Ctx, Expr * Arg, const AttributeCommonInfo &CommonInfo = {SourceRange{}}) {
11998 static PtGuardedByAttr *CreateImplicit(ASTContext &Ctx, Expr * Arg, SourceRange Range, AttributeCommonInfo::Syntax Syntax) {
12002 static PtGuardedByAttr *Create(ASTContext &Ctx, Expr * Arg, SourceRange Range, AttributeCommonInfo::Syntax Syntax) {
12007 , Expr * Arg
12018 Expr * getArg() const {
12352 Expr * *args_;
12368 static ReleaseCapabilityAttr *CreateImplicit(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, const AttributeCommonInfo &CommonInfo = {SourceRange{}}) {
12376 static ReleaseCapabilityAttr *Create(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, const AttributeCommonInfo &CommonInfo = {SourceRange{}}) {
12381 static ReleaseCapabilityAttr *CreateImplicit(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, SourceRange Range, AttributeCommonInfo::Syntax Syntax, ReleaseCapabilityAttr::Spelling S = static_cast<Spelling>(SpellingNotCalculated)) {
12385 static ReleaseCapabilityAttr *Create(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, SourceRange Range, AttributeCommonInfo::Syntax Syntax, ReleaseCapabilityAttr::Spelling S = static_cast<Spelling>(SpellingNotCalculated)) {
12390 , Expr * *Args, unsigned ArgsSize
12393 , args_Size(ArgsSize), args_(new (Ctx, 16) Expr *[args_Size])
12428 typedef Expr ** args_iterator;
12546 Expr * *args_;
12562 static RequiresCapabilityAttr *CreateImplicit(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, const AttributeCommonInfo &CommonInfo = {SourceRange{}}) {
12570 static RequiresCapabilityAttr *Create(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, const AttributeCommonInfo &CommonInfo = {SourceRange{}}) {
12575 static RequiresCapabilityAttr *CreateImplicit(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, SourceRange Range, AttributeCommonInfo::Syntax Syntax, RequiresCapabilityAttr::Spelling S = static_cast<Spelling>(SpellingNotCalculated)) {
12579 static RequiresCapabilityAttr *Create(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, SourceRange Range, AttributeCommonInfo::Syntax Syntax, RequiresCapabilityAttr::Spelling S = static_cast<Spelling>(SpellingNotCalculated)) {
12584 , Expr * *Args, unsigned ArgsSize
12587 , args_Size(ArgsSize), args_(new (Ctx, 16) Expr *[args_Size])
12620 typedef Expr ** args_iterator;
13181 Expr * successValue;
13184 Expr * *args_;
13187 static SharedTrylockFunctionAttr *CreateImplicit(ASTContext &Ctx, Expr * SuccessValue, Expr * *Args, unsigned ArgsSize, const AttributeCommonInfo &CommonInfo = {SourceRange{}}) {
13187 static SharedTrylockFunctionAttr *CreateImplicit(ASTContext &Ctx, Expr * SuccessValue, Expr * *Args, unsigned ArgsSize, const AttributeCommonInfo &CommonInfo = {SourceRange{}}) {
13195 static SharedTrylockFunctionAttr *Create(ASTContext &Ctx, Expr * SuccessValue, Expr * *Args, unsigned ArgsSize, const AttributeCommonInfo &CommonInfo = {SourceRange{}}) {
13195 static SharedTrylockFunctionAttr *Create(ASTContext &Ctx, Expr * SuccessValue, Expr * *Args, unsigned ArgsSize, const AttributeCommonInfo &CommonInfo = {SourceRange{}}) {
13202 static SharedTrylockFunctionAttr *CreateImplicit(ASTContext &Ctx, Expr * SuccessValue, Expr * *Args, unsigned ArgsSize, SourceRange Range, AttributeCommonInfo::Syntax Syntax) {
13202 static SharedTrylockFunctionAttr *CreateImplicit(ASTContext &Ctx, Expr * SuccessValue, Expr * *Args, unsigned ArgsSize, SourceRange Range, AttributeCommonInfo::Syntax Syntax) {
13206 static SharedTrylockFunctionAttr *Create(ASTContext &Ctx, Expr * SuccessValue, Expr * *Args, unsigned ArgsSize, SourceRange Range, AttributeCommonInfo::Syntax Syntax) {
13206 static SharedTrylockFunctionAttr *Create(ASTContext &Ctx, Expr * SuccessValue, Expr * *Args, unsigned ArgsSize, SourceRange Range, AttributeCommonInfo::Syntax Syntax) {
13211 , Expr * SuccessValue
13212 , Expr * *Args, unsigned ArgsSize
13216 , args_Size(ArgsSize), args_(new (Ctx, 16) Expr *[args_Size])
13222 , Expr * SuccessValue
13234 Expr * getSuccessValue() const {
13238 typedef Expr ** args_iterator;
14041 Expr * successValue;
14044 Expr * *args_;
14056 static TryAcquireCapabilityAttr *CreateImplicit(ASTContext &Ctx, Expr * SuccessValue, Expr * *Args, unsigned ArgsSize, const AttributeCommonInfo &CommonInfo = {SourceRange{}}) {
14056 static TryAcquireCapabilityAttr *CreateImplicit(ASTContext &Ctx, Expr * SuccessValue, Expr * *Args, unsigned ArgsSize, const AttributeCommonInfo &CommonInfo = {SourceRange{}}) {
14064 static TryAcquireCapabilityAttr *Create(ASTContext &Ctx, Expr * SuccessValue, Expr * *Args, unsigned ArgsSize, const AttributeCommonInfo &CommonInfo = {SourceRange{}}) {
14064 static TryAcquireCapabilityAttr *Create(ASTContext &Ctx, Expr * SuccessValue, Expr * *Args, unsigned ArgsSize, const AttributeCommonInfo &CommonInfo = {SourceRange{}}) {
14069 static TryAcquireCapabilityAttr *CreateImplicit(ASTContext &Ctx, Expr * SuccessValue, Expr * *Args, unsigned ArgsSize, SourceRange Range, AttributeCommonInfo::Syntax Syntax, TryAcquireCapabilityAttr::Spelling S = static_cast<Spelling>(SpellingNotCalculated)) {
14069 static TryAcquireCapabilityAttr *CreateImplicit(ASTContext &Ctx, Expr * SuccessValue, Expr * *Args, unsigned ArgsSize, SourceRange Range, AttributeCommonInfo::Syntax Syntax, TryAcquireCapabilityAttr::Spelling S = static_cast<Spelling>(SpellingNotCalculated)) {
14073 static TryAcquireCapabilityAttr *Create(ASTContext &Ctx, Expr * SuccessValue, Expr * *Args, unsigned ArgsSize, SourceRange Range, AttributeCommonInfo::Syntax Syntax, TryAcquireCapabilityAttr::Spelling S = static_cast<Spelling>(SpellingNotCalculated)) {
14073 static TryAcquireCapabilityAttr *Create(ASTContext &Ctx, Expr * SuccessValue, Expr * *Args, unsigned ArgsSize, SourceRange Range, AttributeCommonInfo::Syntax Syntax, TryAcquireCapabilityAttr::Spelling S = static_cast<Spelling>(SpellingNotCalculated)) {
14078 , Expr * SuccessValue
14079 , Expr * *Args, unsigned ArgsSize
14083 , args_Size(ArgsSize), args_(new (Ctx, 16) Expr *[args_Size])
14089 , Expr * SuccessValue
14112 Expr * getSuccessValue() const {
14116 typedef Expr ** args_iterator;
gen/tools/clang/include/clang/Sema/AttrTemplateInstantiate.inc 53 auto *tempInstArgs = new (C, 16) Expr *[A->args_size()];
56 Expr * *TI = tempInstArgs;
57 Expr * *I = A->args_begin();
58 Expr * *E = A->args_end();
61 *TI = Result.getAs<Expr>();
68 auto *tempInstArgs = new (C, 16) Expr *[A->args_size()];
71 Expr * *TI = tempInstArgs;
72 Expr * *I = A->args_begin();
73 Expr * *E = A->args_end();
76 *TI = Result.getAs<Expr>();
83 auto *tempInstArgs = new (C, 16) Expr *[A->args_size()];
86 Expr * *TI = tempInstArgs;
87 Expr * *I = A->args_begin();
88 Expr * *E = A->args_end();
91 *TI = Result.getAs<Expr>();
174 auto *tempInstArgs = new (C, 16) Expr *[A->args_size()];
177 Expr * *TI = tempInstArgs;
178 Expr * *I = A->args_begin();
179 Expr * *E = A->args_end();
182 *TI = Result.getAs<Expr>();
189 auto *tempInstArgs = new (C, 16) Expr *[A->args_size()];
192 Expr * *TI = tempInstArgs;
193 Expr * *I = A->args_begin();
194 Expr * *E = A->args_end();
197 *TI = Result.getAs<Expr>();
204 auto *tempInstArgs = new (C, 16) Expr *[A->args_size()];
207 Expr * *TI = tempInstArgs;
208 Expr * *I = A->args_begin();
209 Expr * *E = A->args_end();
212 *TI = Result.getAs<Expr>();
391 Expr * tempInstCond;
395 tempInstCond = Result.getAs<Expr>();
409 Expr * tempInstCond;
413 tempInstCond = Result.getAs<Expr>();
427 Expr * tempInstSuccessValue;
431 tempInstSuccessValue = Result.getAs<Expr>();
433 auto *tempInstArgs = new (C, 16) Expr *[A->args_size()];
436 Expr * *TI = tempInstArgs;
437 Expr * *I = A->args_begin();
438 Expr * *E = A->args_end();
441 *TI = Result.getAs<Expr>();
484 Expr * tempInstArg;
488 tempInstArg = Result.getAs<Expr>();
550 Expr * tempInstArg;
554 tempInstArg = Result.getAs<Expr>();
560 auto *tempInstArgs = new (C, 16) Expr *[A->args_size()];
563 Expr * *TI = tempInstArgs;
564 Expr * *I = A->args_begin();
565 Expr * *E = A->args_end();
568 *TI = Result.getAs<Expr>();
1023 Expr * tempInstArg;
1027 tempInstArg = Result.getAs<Expr>();
1061 auto *tempInstArgs = new (C, 16) Expr *[A->args_size()];
1064 Expr * *TI = tempInstArgs;
1065 Expr * *I = A->args_begin();
1066 Expr * *E = A->args_end();
1069 *TI = Result.getAs<Expr>();
1084 auto *tempInstArgs = new (C, 16) Expr *[A->args_size()];
1087 Expr * *TI = tempInstArgs;
1088 Expr * *I = A->args_begin();
1089 Expr * *E = A->args_end();
1092 *TI = Result.getAs<Expr>();
1139 Expr * tempInstSuccessValue;
1143 tempInstSuccessValue = Result.getAs<Expr>();
1145 auto *tempInstArgs = new (C, 16) Expr *[A->args_size()];
1148 Expr * *TI = tempInstArgs;
1149 Expr * *I = A->args_begin();
1150 Expr * *E = A->args_end();
1153 *TI = Result.getAs<Expr>();
1220 Expr * tempInstSuccessValue;
1224 tempInstSuccessValue = Result.getAs<Expr>();
1226 auto *tempInstArgs = new (C, 16) Expr *[A->args_size()];
1229 Expr * *TI = tempInstArgs;
1230 Expr * *I = A->args_begin();
1231 Expr * *E = A->args_end();
1234 *TI = Result.getAs<Expr>();
gen/tools/clang/include/clang/Serialization/AttrPCHRead.inc 21 Expr * min = Record.readExpr();
22 Expr * max = Record.readExpr();
49 Expr * min = Record.readExpr();
50 Expr * max = Record.readExpr();
100 SmallVector<Expr *, 4> args;
113 SmallVector<Expr *, 4> args;
126 SmallVector<Expr *, 4> args;
159 Expr * alignment = Record.readExpr();
305 SmallVector<Expr *, 4> args;
318 SmallVector<Expr *, 4> args;
331 SmallVector<Expr *, 4> args;
343 Expr * alignment = Record.readExpr();
344 Expr * offset = Record.readExpr();
509 Expr * maxThreads = Record.readExpr();
510 Expr * minBlocks = Record.readExpr();
729 Expr * cond = Record.readExpr();
758 Expr * cond = Record.readExpr();
785 Expr * successValue = Record.readExpr();
787 SmallVector<Expr *, 4> args;
876 Expr * arg = Record.readExpr();
998 Expr * arg = Record.readExpr();
1008 SmallVector<Expr *, 4> args;
1021 Expr * value = Record.readExpr();
1405 Expr * allocator = Record.readExpr();
1429 Expr * simdlen = Record.readExpr();
1431 SmallVector<Expr *, 4> uniforms;
1436 SmallVector<Expr *, 4> aligneds;
1441 SmallVector<Expr *, 4> alignments;
1446 SmallVector<Expr *, 4> linears;
1456 SmallVector<Expr *, 4> steps;
1477 Expr * variantFuncRef = Record.readExpr();
1478 Expr * score = Record.readExpr();
1498 Expr * ref = Record.readExpr();
1973 Expr * arg = Record.readExpr();
2036 SmallVector<Expr *, 4> args;
2066 SmallVector<Expr *, 4> args;
2161 Expr * successValue = Record.readExpr();
2163 SmallVector<Expr *, 4> args;
2303 Expr * successValue = Record.readExpr();
2305 SmallVector<Expr *, 4> args;
include/llvm/ADT/ArrayRef.h 108 const ArrayRef<U *> &A,
110 std::is_convertible<U *const *, T const *>::value>::type * = nullptr)
118 const SmallVectorTemplateCommon<U *, DummyT> &Vec,
120 std::is_convertible<U *const *, T const *>::value>::type * = nullptr)
include/llvm/ADT/DenseMapInfo.h 39 static inline T* getEmptyKey() {
41 Val <<= PointerLikeTypeTraits<T*>::NumLowBitsAvailable;
45 static inline T* getTombstoneKey() {
47 Val <<= PointerLikeTypeTraits<T*>::NumLowBitsAvailable;
51 static unsigned getHashValue(const T *PtrVal) {
56 static bool isEqual(const T *LHS, const T *RHS) { return LHS == RHS; }
56 static bool isEqual(const T *LHS, const T *RHS) { return LHS == RHS; }
include/llvm/ADT/STLExtras.h 75 typename std::add_pointer<typename std::add_const<T>::type>::type;
include/llvm/ADT/SmallSet.h 249 class SmallSet<PointeeType*, N> : public SmallPtrSet<PointeeType*, N> {};
include/llvm/Support/Casting.h 34 using SimpleType = From; // The real type this represents...
37 static SimpleType &getSimplifiedValue(From &Val) { return Val; }
41 using NonConstSimpleType = typename simplify_type<From>::SimpleType;
47 static RetType getSimplifiedValue(const From& Val) {
57 static inline bool doit(const From &Val) {
58 return To::classof(&Val);
66 static inline bool doit(const From &) { return true; }
76 static inline bool doit(const From &Val) {
77 return isa_impl<To, From>::doit(Val);
104 static inline bool doit(const From *Val) {
106 return isa_impl<To, From>::doit(*Val);
106 return isa_impl<To, From>::doit(*Val);
122 return isa_impl_wrap<To, SimpleFrom,
132 return isa_impl_cl<To,FromTy>::doit(Val);
141 template <class X, class Y> LLVM_NODISCARD inline bool isa(const Y &Val) {
142 return isa_impl_wrap<X, const Y,
142 return isa_impl_wrap<X, const Y,
143 typename simplify_type<const Y>::SimpleType>::doit(Val);
153 return isa<X>(Val);
172 using ret_type = To *; // Pointer arg case, return Ty*
176 using ret_type = const To *; // Constant pointer arg case, return const Ty*
198 using ret_type = typename cast_retty<To, SimpleFrom>::ret_type;
204 using ret_type = typename cast_retty_impl<To,FromTy>::ret_type;
210 To, From, typename simplify_type<From>::SimpleType>::ret_type;
227 static typename cast_retty<To, FromTy>::ret_type doit(const FromTy &Val) {
228 typename cast_retty<To, FromTy>::ret_type Res2
236 std::is_same<X, typename simplify_type<X>::SimpleType>::value;
236 std::is_same<X, typename simplify_type<X>::SimpleType>::value;
256 inline typename cast_retty<X, Y>::ret_type cast(Y &Val) {
263 inline typename cast_retty<X, Y *>::ret_type cast(Y *Val) {
263 inline typename cast_retty<X, Y *>::ret_type cast(Y *Val) {
263 inline typename cast_retty<X, Y *>::ret_type cast(Y *Val) {
265 return cast_convert_val<X, Y*,
265 return cast_convert_val<X, Y*,
266 typename simplify_type<Y*>::SimpleType>::doit(Val);
296 typename cast_retty<X, Y>::ret_type>::type
305 LLVM_NODISCARD inline typename cast_retty<X, Y *>::ret_type
305 LLVM_NODISCARD inline typename cast_retty<X, Y *>::ret_type
306 cast_or_null(Y *Val) {
309 return cast<X>(Val);
337 LLVM_NODISCARD inline typename cast_retty<X, Y>::ret_type dyn_cast(Y &Val) {
342 LLVM_NODISCARD inline typename cast_retty<X, Y *>::ret_type dyn_cast(Y *Val) {
342 LLVM_NODISCARD inline typename cast_retty<X, Y *>::ret_type dyn_cast(Y *Val) {
342 LLVM_NODISCARD inline typename cast_retty<X, Y *>::ret_type dyn_cast(Y *Val) {
343 return isa<X>(Val) ? cast<X>(Val) : nullptr;
343 return isa<X>(Val) ? cast<X>(Val) : nullptr;
366 LLVM_NODISCARD inline typename cast_retty<X, Y *>::ret_type
366 LLVM_NODISCARD inline typename cast_retty<X, Y *>::ret_type
367 dyn_cast_or_null(Y *Val) {
368 return (Val && isa<X>(Val)) ? cast<X>(Val) : nullptr;
368 return (Val && isa<X>(Val)) ? cast<X>(Val) : nullptr;
include/llvm/Support/PointerLikeTypeTraits.h 56 static inline void *getAsVoidPointer(T *P) { return P; }
57 static inline T *getFromVoidPointer(void *P) { return static_cast<T *>(P); }
59 enum { NumLowBitsAvailable = detail::ConstantLog2<alignof(T)>::value };
91 typedef PointerLikeTypeTraits<T *> NonConst;
93 static inline const void *getAsVoidPointer(const T *P) {
96 static inline const T *getFromVoidPointer(const void *P) {
include/llvm/Support/type_traits.h 55 struct add_const_past_pointer { using type = const T; };
tools/clang/include/clang/AST/APValue.h 139 typedef llvm::PointerUnion<const ValueDecl *, const Expr *, TypeInfoLValue,
146 LValueBase(const Expr *P, unsigned I = 0, unsigned V = 0);
tools/clang/include/clang/AST/ASTContext.h 166 BlockVarCopyInit(Expr *CopyExpr, bool CanThrow)
168 void setExprAndFlag(Expr *CopyExpr, bool CanThrow) {
171 Expr *getCopyExpr() const { return ExprAndFlag.getPointer(); }
173 llvm::PointerIntPair<Expr *, 1, bool> ExprAndFlag;
664 template <typename NodeT> DynTypedNodeList getParents(const NodeT &Node) {
1312 QualType getVariableArrayType(QualType EltTy, Expr *NumElts,
1322 QualType getDependentSizedArrayType(QualType EltTy, Expr *NumElts,
1336 const Expr *SizeExpr,
1355 QualType getDependentVectorType(QualType VectorType, Expr *SizeExpr,
1371 Expr *SizeExpr,
1375 Expr *AddrSpaceExpr,
1520 QualType getTypeOfExprType(Expr *e) const;
1524 QualType getDecltypeType(Expr *e, QualType UnderlyingType) const;
2513 QualType isPromotableBitField(Expr *E) const;
2694 bool isSentinelNullExpr(const Expr *E);
2732 void setBlockVarCopyInit(const VarDecl* VD, Expr *CopyExpr, bool CanThrow);
tools/clang/include/clang/AST/ASTImporter.h 413 llvm::Expected<Expr *> Import(Expr *FromE);
413 llvm::Expected<Expr *> Import(Expr *FromE);
tools/clang/include/clang/AST/ASTMutationListener.h 85 Expr *ThisArg) {}
tools/clang/include/clang/AST/ASTNodeTraverser.h 241 if (const Expr *RC = TPL->getRequiresClause())
352 if (const Expr *Init = D->getInitExpr())
375 if (Expr *Init = D->getInClassInitializer())
391 if (const auto *E = D->getBinding())
402 for (const auto *E : D->varlists())
408 if (const auto *Initializer = D->getInitializer())
422 for (const auto *E : D->varlists())
615 if (Expr *Source = Node->getSourceExpr())
tools/clang/include/clang/AST/ASTTypeTraits.h 65 return ASTNodeKind(KindToKindId<T>::Id);
174 struct KindToKindId<const T> : KindToKindId<T> {};
234 static DynTypedNode create(const T &Node) {
235 return BaseConverter<T>::create(Node);
251 const T *get() const {
252 return BaseConverter<T>::get(NodeKind, Storage.buffer);
259 const T &getUnchecked() const {
260 return BaseConverter<T>::getUnchecked(NodeKind, Storage.buffer);
394 static const T *get(ASTNodeKind NodeKind, const char Storage[]) {
395 if (ASTNodeKind::getFromNodeKind<T>().isBaseOf(NodeKind))
399 static const T &getUnchecked(ASTNodeKind NodeKind, const char Storage[]) {
401 return *cast<T>(static_cast<const BaseT *>(
474 : public DynCastPtrConverter<T, Stmt> {};
tools/clang/include/clang/AST/CurrentSourceLocExprScope.h 28 const Expr *DefaultExpr = nullptr;
36 const Expr *getDefaultExpr() const { return DefaultExpr; }
41 explicit CurrentSourceLocExprScope(const Expr *DefaultExpr)
51 SourceLocExprScopeGuard(const Expr *DefaultExpr,
tools/clang/include/clang/AST/Decl.h 1225 const Expr *getAnyInitializer() const {
1232 const Expr *getAnyInitializer(const VarDecl *&D) const;
1235 const Expr *getInit() const {
1238 Expr *getInit();
1243 void setInit(Expr *I);
1609 TypeSourceInfo *TInfo, StorageClass S, Expr *DefArg)
1623 StorageClass S, Expr *DefArg);
1682 Expr *getDefaultArg();
1683 const Expr *getDefaultArg() const {
1687 void setDefaultArg(Expr *defarg);
1692 void setUninstantiatedDefaultArg(Expr *arg);
1693 Expr *getUninstantiatedDefaultArg();
1694 const Expr *getUninstantiatedDefaultArg() const {
2681 Expr *Init;
2682 Expr *BitWidth;
2699 QualType T, TypeSourceInfo *TInfo, Expr *BW, bool Mutable,
2715 TypeSourceInfo *TInfo, Expr *BW, bool Mutable,
2739 Expr *getBitWidth() const {
2752 void setBitWidth(Expr *Width) {
2797 Expr *getInClassInitializer() const {
2807 void setInClassInitializer(Expr *Init) {
2868 IdentifierInfo *Id, QualType T, Expr *E,
2877 QualType T, Expr *E,
2881 const Expr *getInitExpr() const { return (const Expr*) Init; }
2882 Expr *getInitExpr() { return (Expr*) Init; }
2885 void setInitExpr(Expr *E) { Init = (Stmt*) E; }
3976 Expr *CopyExpr;
3979 Capture(VarDecl *variable, bool byRef, bool nested, Expr *copy)
4004 Expr *getCopyExpr() const { return CopyExpr; }
4005 void setCopyExpr(Expr *e) { CopyExpr = e; }
tools/clang/include/clang/AST/DeclCXX.h 1793 llvm::PointerIntPair<Expr *, 2, ExplicitSpecKind> ExplicitSpec{
1798 ExplicitSpecifier(Expr *Expression, ExplicitSpecKind Kind)
1801 const Expr *getExpr() const { return ExplicitSpec.getPointer(); }
1802 Expr *getExpr() { return ExplicitSpec.getPointer(); }
1824 void setExpr(Expr *E) { ExplicitSpec.setPointer(E); }
1964 CXXMethodDecl *getDevirtualizedMethod(const Expr *Base, bool IsAppleKext);
1966 const CXXMethodDecl *getDevirtualizedMethod(const Expr *Base,
2182 SourceLocation L, Expr *Init, SourceLocation R,
2188 SourceLocation MemberLoc, SourceLocation L, Expr *Init,
2194 SourceLocation MemberLoc, SourceLocation L, Expr *Init,
2200 SourceLocation L, Expr *Init, SourceLocation R);
2335 Expr *getInit() const { return static_cast<Expr *>(Init); }
2636 Expr *OperatorDeleteThisArg = nullptr;
2658 void setOperatorDelete(FunctionDecl *OD, Expr *ThisArg);
2664 Expr *getOperatorDeleteThisArg() const {
3670 llvm::PointerIntPair<Expr *, 1, bool> AssertExprAndFailed;
3675 Expr *AssertExpr, StringLiteral *Message,
3688 Expr *AssertExpr, StringLiteral *Message,
3692 Expr *getAssertExpr() { return AssertExprAndFailed.getPointer(); }
3693 const Expr *getAssertExpr() const { return AssertExprAndFailed.getPointer(); }
3725 Expr *Binding = nullptr;
3742 Expr *getBinding() const { return Binding; }
3755 void setBinding(QualType DeclaredType, Expr *Binding) {
tools/clang/include/clang/AST/DeclObjC.h 1955 QualType T, TypeSourceInfo *TInfo, AccessControl ac, Expr *BW,
1966 AccessControl ac, Expr *BW = nullptr,
2014 QualType T, Expr *BW)
2025 QualType T, Expr *BW);
2784 Expr *GetterCXXConstructor = nullptr;
2788 Expr *SetterCXXAssignment = nullptr;
2848 Expr *getGetterCXXConstructor() const {
2852 void setGetterCXXConstructor(Expr *getterCXXConstructor) {
2856 Expr *getSetterCXXAssignment() const {
2860 void setSetterCXXAssignment(Expr *setterCXXAssignment) {
tools/clang/include/clang/AST/DeclOpenMP.h 41 private llvm::TrailingObjects<OMPThreadPrivateDecl, Expr *> {
52 ArrayRef<const Expr *> getVars() const {
53 return llvm::makeArrayRef(getTrailingObjects<Expr *>(), NumVars);
56 MutableArrayRef<Expr *> getVars() {
57 return MutableArrayRef<Expr *>(getTrailingObjects<Expr *>(), NumVars);
60 void setVars(ArrayRef<Expr *> VL);
65 ArrayRef<Expr *> VL);
69 typedef MutableArrayRef<Expr *>::iterator varlist_iterator;
70 typedef ArrayRef<const Expr *>::iterator varlist_const_iterator;
115 Expr *Combiner = nullptr;
117 Expr *Initializer = nullptr;
119 Expr *In = nullptr;
121 Expr *Out = nullptr;
123 Expr *Priv = nullptr;
125 Expr *Orig = nullptr;
152 Expr *getCombiner() { return Combiner; }
153 const Expr *getCombiner() const { return Combiner; }
155 Expr *getCombinerIn() { return In; }
156 const Expr *getCombinerIn() const { return In; }
158 Expr *getCombinerOut() { return Out; }
159 const Expr *getCombinerOut() const { return Out; }
161 void setCombiner(Expr *E) { Combiner = E; }
163 void setCombinerData(Expr *InE, Expr *OutE) {
163 void setCombinerData(Expr *InE, Expr *OutE) {
170 Expr *getInitializer() { return Initializer; }
171 const Expr *getInitializer() const { return Initializer; }
177 Expr *getInitOrig() { return Orig; }
178 const Expr *getInitOrig() const { return Orig; }
180 Expr *getInitPriv() { return Priv; }
181 const Expr *getInitPriv() const { return Priv; }
183 void setInitializer(Expr *E, InitKind IK) {
188 void setInitializerData(Expr *OrigE, Expr *PrivE) {
188 void setInitializerData(Expr *OrigE, Expr *PrivE) {
224 Expr *MapperVarRef = nullptr;
282 Expr *getMapperVarRef() { return MapperVarRef; }
283 const Expr *getMapperVarRef() const { return MapperVarRef; }
285 void setMapperVarRef(Expr *MapperVarRefE) { MapperVarRef = MapperVarRefE; }
424 private llvm::TrailingObjects<OMPAllocateDecl, Expr *, OMPClause *> {
433 size_t numTrailingObjects(OverloadToken<Expr *>) const {
445 ArrayRef<const Expr *> getVars() const {
446 return llvm::makeArrayRef(getTrailingObjects<Expr *>(), NumVars);
449 MutableArrayRef<Expr *> getVars() {
450 return MutableArrayRef<Expr *>(getTrailingObjects<Expr *>(), NumVars);
453 void setVars(ArrayRef<Expr *> VL);
471 SourceLocation L, ArrayRef<Expr *> VL,
476 typedef MutableArrayRef<Expr *>::iterator varlist_iterator;
477 typedef ArrayRef<const Expr *>::iterator varlist_const_iterator;
tools/clang/include/clang/AST/DeclTemplate.h 69 Expr *> {
90 Expr *RequiresClause);
96 size_t numTrailingObjects(OverloadToken<Expr *>) const {
110 Expr *RequiresClause);
162 Expr *getRequiresClause() {
163 return HasRequiresClause ? *getTrailingObjects<Expr *>() : nullptr;
167 const Expr *getRequiresClause() const {
168 return HasRequiresClause ? *getTrailingObjects<Expr *>() : nullptr;
177 void getAssociatedConstraints(llvm::SmallVectorImpl<const Expr *> &AC) const;
206 NamedDecl *, Expr *>::with_counts<
215 Expr *RequiresClause)
414 void getAssociatedConstraints(llvm::SmallVectorImpl<const Expr *> &AC) const;
1263 using DefArgStorage = DefaultArgStorage<NonTypeTemplateParmDecl, Expr *>;
1332 Expr *getDefaultArgument() const { return DefaultArgument.get(); }
1346 void setDefaultArgument(Expr *DefArg) { DefaultArgument.set(DefArg); }
1971 void getAssociatedConstraints(llvm::SmallVectorImpl<const Expr *> &AC) const {
2813 void getAssociatedConstraints(llvm::SmallVectorImpl<const Expr *> &AC) const {
3048 Expr *ConstraintExpr;
3051 TemplateParameterList *Params, Expr *ConstraintExpr)
3058 Expr *ConstraintExpr);
3061 Expr *getConstraintExpr() const {
tools/clang/include/clang/AST/Expr.h 77 Expr *RHS;
98 SubobjectAdjustment(const MemberPointerType *MPT, Expr *RHS)
113 Expr(const Expr&) = delete;
114 Expr(Expr &&) = delete;
115 Expr &operator=(const Expr&) = delete;
115 Expr &operator=(const Expr&) = delete;
116 Expr &operator=(Expr&&) = delete;
116 Expr &operator=(Expr&&) = delete;
241 bool isUnusedResultAWarning(const Expr *&WarnExpr, SourceLocation &Loc,
537 static bool isPotentialConstantExprUnevaluated(Expr *E,
547 const Expr **Culprit = nullptr) const;
682 ArrayRef<const Expr*> Args,
683 const Expr *This = nullptr) const;
757 static QualType findBoundMemberType(const Expr *expr);
763 Expr *IgnoreImpCasts() LLVM_READONLY;
764 const Expr *IgnoreImpCasts() const {
774 Expr *IgnoreCasts() LLVM_READONLY;
775 const Expr *IgnoreCasts() const {
784 Expr *IgnoreImplicit() LLVM_READONLY;
785 const Expr *IgnoreImplicit() const {
796 Expr *IgnoreParens() LLVM_READONLY;
797 const Expr *IgnoreParens() const {
810 Expr *IgnoreParenImpCasts() LLVM_READONLY;
811 const Expr *IgnoreParenImpCasts() const {
819 Expr *IgnoreParenCasts() LLVM_READONLY;
820 const Expr *IgnoreParenCasts() const {
826 Expr *IgnoreConversionOperator() LLVM_READONLY;
827 const Expr *IgnoreConversionOperator() const {
839 Expr *IgnoreParenLValueCasts() LLVM_READONLY;
840 const Expr *IgnoreParenLValueCasts() const {
850 Expr *IgnoreParenNoopCasts(const ASTContext &Ctx) LLVM_READONLY;
851 const Expr *IgnoreParenNoopCasts(const ASTContext &Ctx) const {
860 Expr *ignoreParenBaseCasts() LLVM_READONLY;
861 const Expr *ignoreParenBaseCasts() const {
881 static bool hasAnyTypeDependentArguments(ArrayRef<Expr *> Exprs);
895 const Expr *getBestDynamicClassTypeExpr() const;
900 const Expr *skipRValueSubobjectAdjustments(
901 SmallVectorImpl<const Expr *> &CommaLHS,
903 const Expr *skipRValueSubobjectAdjustments() const {
904 SmallVector<const Expr *, 8> CommaLHSs;
912 static bool isSameComparisonOperand(const Expr* E1, const Expr* E2);
912 static bool isSameComparisonOperand(const Expr* E1, const Expr* E2);
925 class FullExpr : public Expr {
929 FullExpr(StmtClass SC, Expr *subexpr)
938 const Expr *getSubExpr() const { return cast<Expr>(SubExpr); }
938 const Expr *getSubExpr() const { return cast<Expr>(SubExpr); }
939 Expr *getSubExpr() { return cast<Expr>(SubExpr); }
939 Expr *getSubExpr() { return cast<Expr>(SubExpr); }
943 void setSubExpr(Expr *E) { SubExpr = E; }
990 ConstantExpr(Expr *subexpr, ResultStorageKind StorageKind);
997 static ConstantExpr *Create(const ASTContext &Context, Expr *E,
999 static ConstantExpr *Create(const ASTContext &Context, Expr *E,
1050 class OpaqueValueExpr : public Expr {
1052 Expr *SourceExpr;
1057 Expr *SourceExpr = nullptr)
1074 static const OpaqueValueExpr *findInCopyConstruct(const Expr *expr);
1108 Expr *getSourceExpr() const { return SourceExpr; }
1147 : public Expr,
1421 class IntegerLiteral : public Expr, public APIntStorage {
1464 class FixedPointLiteral : public Expr, public APIntStorage {
1505 class CharacterLiteral : public Expr {
1558 class FloatingLiteral : public Expr, private APFloatStorage {
1637 class ImaginaryLiteral : public Expr {
1640 ImaginaryLiteral(Expr *val, QualType Ty)
1649 const Expr *getSubExpr() const { return cast<Expr>(Val); }
1649 const Expr *getSubExpr() const { return cast<Expr>(Val); }
1650 Expr *getSubExpr() { return cast<Expr>(Val); }
1650 Expr *getSubExpr() { return cast<Expr>(Val); }
1651 void setSubExpr(Expr *E) { Val = E; }
1687 : public Expr,
1879 : public Expr,
1969 class ParenExpr : public Expr {
1973 ParenExpr(SourceLocation l, SourceLocation r, Expr *val)
1985 const Expr *getSubExpr() const { return cast<Expr>(Val); }
1985 const Expr *getSubExpr() const { return cast<Expr>(Val); }
1986 Expr *getSubExpr() { return cast<Expr>(Val); }
1986 Expr *getSubExpr() { return cast<Expr>(Val); }
1987 void setSubExpr(Expr *E) { Val = E; }
2021 class UnaryOperator : public Expr {
2027 UnaryOperator(Expr *input, Opcode opc, QualType type, ExprValueKind VK,
2051 Expr *getSubExpr() const { return cast<Expr>(Val); }
2051 Expr *getSubExpr() const { return cast<Expr>(Val); }
2052 void setSubExpr(Expr *E) { Val = E; }
2243 : public Expr,
2244 private llvm::TrailingObjects<OffsetOfExpr, OffsetOfNode, Expr *> {
2259 ArrayRef<OffsetOfNode> comps, ArrayRef<Expr*> exprs,
2271 ArrayRef<Expr*> exprs, SourceLocation RParenLoc);
2305 Expr* getIndexExpr(unsigned Idx) {
2307 return getTrailingObjects<Expr *>()[Idx];
2310 const Expr *getIndexExpr(unsigned Idx) const {
2312 return getTrailingObjects<Expr *>()[Idx];
2315 void setIndexExpr(unsigned Idx, Expr* E) {
2317 getTrailingObjects<Expr *>()[Idx] = E;
2333 Stmt **begin = reinterpret_cast<Stmt **>(getTrailingObjects<Expr *>());
2338 reinterpret_cast<Stmt *const *>(getTrailingObjects<Expr *>());
2347 class UnaryExprOrTypeTraitExpr : public Expr {
2370 UnaryExprOrTypeTraitExpr(UnaryExprOrTypeTrait ExprKind, Expr *E,
2391 Expr *getArgumentExpr() {
2395 const Expr *getArgumentExpr() const {
2399 void setArgument(Expr *E) {
2437 class ArraySubscriptExpr : public Expr {
2444 ArraySubscriptExpr(Expr *lhs, Expr *rhs, QualType t,
2444 ArraySubscriptExpr(Expr *lhs, Expr *rhs, QualType t,
2472 Expr *getLHS() { return cast<Expr>(SubExprs[LHS]); }
2472 Expr *getLHS() { return cast<Expr>(SubExprs[LHS]); }
2473 const Expr *getLHS() const { return cast<Expr>(SubExprs[LHS]); }
2473 const Expr *getLHS() const { return cast<Expr>(SubExprs[LHS]); }
2474 void setLHS(Expr *E) { SubExprs[LHS] = E; }
2476 Expr *getRHS() { return cast<Expr>(SubExprs[RHS]); }
2476 Expr *getRHS() { return cast<Expr>(SubExprs[RHS]); }
2477 const Expr *getRHS() const { return cast<Expr>(SubExprs[RHS]); }
2477 const Expr *getRHS() const { return cast<Expr>(SubExprs[RHS]); }
2478 void setRHS(Expr *E) { SubExprs[RHS] = E; }
2480 Expr *getBase() { return lhsIsBase() ? getLHS() : getRHS(); }
2481 const Expr *getBase() const { return lhsIsBase() ? getLHS() : getRHS(); }
2483 Expr *getIdx() { return lhsIsBase() ? getRHS() : getLHS(); }
2484 const Expr *getIdx() const { return lhsIsBase() ? getRHS() : getLHS(); }
2521 class CallExpr : public Expr {
2531 void updateDependenciesFromArg(Expr *Arg);
2575 CallExpr(StmtClass SC, Expr *Fn, ArrayRef<Expr *> PreArgs,
2575 CallExpr(StmtClass SC, Expr *Fn, ArrayRef<Expr *> PreArgs,
2576 ArrayRef<Expr *> Args, QualType Ty, ExprValueKind VK,
2617 static CallExpr *Create(const ASTContext &Ctx, Expr *Fn,
2618 ArrayRef<Expr *> Args, QualType Ty, ExprValueKind VK,
2630 static CallExpr *CreateTemporary(void *Mem, Expr *Fn, QualType Ty,
2638 Expr *getCallee() { return cast<Expr>(getTrailingStmts()[FN]); }
2638 Expr *getCallee() { return cast<Expr>(getTrailingStmts()[FN]); }
2639 const Expr *getCallee() const { return cast<Expr>(getTrailingStmts()[FN]); }
2639 const Expr *getCallee() const { return cast<Expr>(getTrailingStmts()[FN]); }
2640 void setCallee(Expr *F) { getTrailingStmts()[FN] = F; }
2667 Expr **getArgs() {
2671 const Expr *const *getArgs() const {
2677 Expr *getArg(unsigned Arg) {
2681 const Expr *getArg(unsigned Arg) const {
2687 void setArg(unsigned Arg, Expr *ArgExpr) {
2812 : public Expr,
2852 MemberExpr(Expr *Base, bool IsArrow, SourceLocation OperatorLoc,
2860 static MemberExpr *Create(const ASTContext &C, Expr *Base, bool IsArrow,
2872 static MemberExpr *CreateImplicit(const ASTContext &C, Expr *Base,
2887 void setBase(Expr *E) { Base = E; }
2888 Expr *getBase() const { return cast<Expr>(Base); }
2888 Expr *getBase() const { return cast<Expr>(Base); }
3052 class CompoundLiteralExpr : public Expr {
3065 QualType T, ExprValueKind VK, Expr *init, bool fileScope)
3078 const Expr *getInitializer() const { return cast<Expr>(Init); }
3078 const Expr *getInitializer() const { return cast<Expr>(Init); }
3079 Expr *getInitializer() { return cast<Expr>(Init); }
3079 Expr *getInitializer() { return cast<Expr>(Init); }
3080 void setInitializer(Expr *E) { Init = E; }
3125 class CastExpr : public Expr {
3137 Expr *op, unsigned BasePathSize)
3177 Expr *getSubExpr() { return cast<Expr>(Op); }
3177 Expr *getSubExpr() { return cast<Expr>(Op); }
3178 const Expr *getSubExpr() const { return cast<Expr>(Op); }
3178 const Expr *getSubExpr() const { return cast<Expr>(Op); }
3179 void setSubExpr(Expr *E) { Op = E; }
3184 Expr *getSubExprAsWritten();
3185 const Expr *getSubExprAsWritten() const {
3253 ImplicitCastExpr(QualType ty, CastKind kind, Expr *op,
3263 ImplicitCastExpr(OnStack_t _, QualType ty, CastKind kind, Expr *op,
3274 CastKind Kind, Expr *Operand,
3319 CastKind kind, Expr *op, unsigned PathSize,
3352 CStyleCastExpr(QualType exprTy, ExprValueKind vk, CastKind kind, Expr *op,
3365 Expr *Op, const CXXCastPath *BasePath,
3409 class BinaryOperator : public Expr {
3416 BinaryOperator(Expr *lhs, Expr *rhs, Opcode opc, QualType ResTy,
3416 BinaryOperator(Expr *lhs, Expr *rhs, Opcode opc, QualType ResTy,
3449 Expr *getLHS() const { return cast<Expr>(SubExprs[LHS]); }
3449 Expr *getLHS() const { return cast<Expr>(SubExprs[LHS]); }
3450 void setLHS(Expr *E) { SubExprs[LHS] = E; }
3451 Expr *getRHS() const { return cast<Expr>(SubExprs[RHS]); }
3451 Expr *getRHS() const { return cast<Expr>(SubExprs[RHS]); }
3452 void setRHS(Expr *E) { SubExprs[RHS] = E; }
3565 Expr *LHS, Expr *RHS);
3565 Expr *LHS, Expr *RHS);
3601 BinaryOperator(Expr *lhs, Expr *rhs, Opcode opc, QualType ResTy,
3601 BinaryOperator(Expr *lhs, Expr *rhs, Opcode opc, QualType ResTy,
3633 CompoundAssignOperator(Expr *lhs, Expr *rhs, Opcode opc, QualType ResType,
3633 CompoundAssignOperator(Expr *lhs, Expr *rhs, Opcode opc, QualType ResType,
3665 class AbstractConditionalOperator : public Expr {
3685 Expr *getCond() const;
3689 Expr *getTrueExpr() const;
3694 Expr *getFalseExpr() const;
3713 ConditionalOperator(Expr *cond, SourceLocation QLoc, Expr *lhs,
3713 ConditionalOperator(Expr *cond, SourceLocation QLoc, Expr *lhs,
3714 SourceLocation CLoc, Expr *rhs,
3741 Expr *getCond() const { return cast<Expr>(SubExprs[COND]); }
3741 Expr *getCond() const { return cast<Expr>(SubExprs[COND]); }
3745 Expr *getTrueExpr() const { return cast<Expr>(SubExprs[LHS]); }
3745 Expr *getTrueExpr() const { return cast<Expr>(SubExprs[LHS]); }
3750 Expr *getFalseExpr() const { return cast<Expr>(SubExprs[RHS]); }
3750 Expr *getFalseExpr() const { return cast<Expr>(SubExprs[RHS]); }
3752 Expr *getLHS() const { return cast<Expr>(SubExprs[LHS]); }
3752 Expr *getLHS() const { return cast<Expr>(SubExprs[LHS]); }
3753 Expr *getRHS() const { return cast<Expr>(SubExprs[RHS]); }
3753 Expr *getRHS() const { return cast<Expr>(SubExprs[RHS]); }
3793 BinaryConditionalOperator(Expr *common, OpaqueValueExpr *opaqueValue,
3794 Expr *cond, Expr *lhs, Expr *rhs,
3794 Expr *cond, Expr *lhs, Expr *rhs,
3794 Expr *cond, Expr *lhs, Expr *rhs,
3820 Expr *getCommon() const { return cast<Expr>(SubExprs[COMMON]); }
3820 Expr *getCommon() const { return cast<Expr>(SubExprs[COMMON]); }
3827 Expr *getCond() const { return cast<Expr>(SubExprs[COND]); }
3827 Expr *getCond() const { return cast<Expr>(SubExprs[COND]); }
3832 Expr *getTrueExpr() const {
3833 return cast<Expr>(SubExprs[LHS]);
3839 Expr *getFalseExpr() const {
3840 return cast<Expr>(SubExprs[RHS]);
3863 inline Expr *AbstractConditionalOperator::getCond() const {
3869 inline Expr *AbstractConditionalOperator::getTrueExpr() const {
3875 inline Expr *AbstractConditionalOperator::getFalseExpr() const {
3882 class AddrLabelExpr : public Expr {
3926 class StmtExpr : public Expr {
3971 class ShuffleVectorExpr : public Expr {
3982 ShuffleVectorExpr(const ASTContext &C, ArrayRef<Expr*> args, QualType Type,
4008 Expr **getSubExprs() { return reinterpret_cast<Expr **>(SubExprs); }
4011 Expr *getExpr(unsigned Index) {
4013 return cast<Expr>(SubExprs[Index]);
4015 const Expr *getExpr(unsigned Index) const {
4017 return cast<Expr>(SubExprs[Index]);
4020 void setExprs(const ASTContext &C, ArrayRef<Expr *> Exprs);
4039 class ConvertVectorExpr : public Expr {
4050 ConvertVectorExpr(Expr* SrcExpr, TypeSourceInfo *TI, QualType DstType,
4063 Expr *getSrcExpr() const { return cast<Expr>(SrcExpr); }
4063 Expr *getSrcExpr() const { return cast<Expr>(SrcExpr); }
4102 class ChooseExpr : public Expr {
4108 ChooseExpr(SourceLocation BLoc, Expr *cond, Expr *lhs, Expr *rhs,
4108 ChooseExpr(SourceLocation BLoc, Expr *cond, Expr *lhs, Expr *rhs,
4108 ChooseExpr(SourceLocation BLoc, Expr *cond, Expr *lhs, Expr *rhs,
4143 Expr *getChosenSubExpr() const {
4147 Expr *getCond() const { return cast<Expr>(SubExprs[COND]); }
4147 Expr *getCond() const { return cast<Expr>(SubExprs[COND]); }
4148 void setCond(Expr *E) { SubExprs[COND] = E; }
4149 Expr *getLHS() const { return cast<Expr>(SubExprs[LHS]); }
4149 Expr *getLHS() const { return cast<Expr>(SubExprs[LHS]); }
4150 void setLHS(Expr *E) { SubExprs[LHS] = E; }
4151 Expr *getRHS() const { return cast<Expr>(SubExprs[RHS]); }
4151 Expr *getRHS() const { return cast<Expr>(SubExprs[RHS]); }
4152 void setRHS(Expr *E) { SubExprs[RHS] = E; }
4182 class GNUNullExpr : public Expr {
4216 class VAArgExpr : public Expr {
4221 VAArgExpr(SourceLocation BLoc, Expr *e, TypeSourceInfo *TInfo,
4234 const Expr *getSubExpr() const { return cast<Expr>(Val); }
4234 const Expr *getSubExpr() const { return cast<Expr>(Val); }
4235 Expr *getSubExpr() { return cast<Expr>(Val); }
4235 Expr *getSubExpr() { return cast<Expr>(Val); }
4236 void setSubExpr(Expr *E) { Val = E; }
4267 class SourceLocExpr final : public Expr {
4283 const Expr *DefaultExpr) const;
4375 class InitListExpr : public Expr {
4395 llvm::PointerUnion<Expr *, FieldDecl *> ArrayFillerOrUnionFieldInit;
4399 ArrayRef<Expr*> initExprs, SourceLocation rbraceloc);
4408 Expr **getInits() { return reinterpret_cast<Expr **>(InitExprs.data()); }
4411 Expr * const *getInits() const {
4415 ArrayRef<Expr *> inits() {
4419 ArrayRef<Expr *> inits() const {
4423 const Expr *getInit(unsigned Init) const {
4425 return cast_or_null<Expr>(InitExprs[Init]);
4428 Expr *getInit(unsigned Init) {
4430 return cast_or_null<Expr>(InitExprs[Init]);
4433 void setInit(unsigned Init, Expr *expr) {
4464 Expr *updateInit(const ASTContext &C, unsigned Init, Expr *expr);
4464 Expr *updateInit(const ASTContext &C, unsigned Init, Expr *expr);
4469 Expr *getArrayFiller() {
4470 return ArrayFillerOrUnionFieldInit.dyn_cast<Expr *>();
4472 const Expr *getArrayFiller() const {
4475 void setArrayFiller(Expr *filler);
4612 : public Expr,
4642 ArrayRef<Expr *> IndexExprs, Expr *Init);
4642 ArrayRef<Expr *> IndexExprs, Expr *Init);
4803 ArrayRef<Expr*> IndexExprs,
4805 bool GNUSyntax, Expr *Init);
4830 Expr *getArrayIndex(const Designator &D) const;
4831 Expr *getArrayRangeStart(const Designator &D) const;
4832 Expr *getArrayRangeEnd(const Designator &D) const;
4849 Expr *getInit() const {
4850 return cast<Expr>(*const_cast<DesignatedInitExpr*>(this)->child_begin());
4853 void setInit(Expr *init) {
4863 Expr *getSubExpr(unsigned Idx) const {
4865 return cast<Expr>(getTrailingObjects<Stmt *>()[Idx]);
4868 void setSubExpr(unsigned Idx, Expr *E) {
4909 class NoInitExpr : public Expr {
4945 class DesignatedInitUpdateExpr : public Expr {
4952 Expr *baseExprs, SourceLocation rBraceLoc);
4964 Expr *getBase() const { return cast<Expr>(BaseAndUpdaterExprs[0]); }
4964 Expr *getBase() const { return cast<Expr>(BaseAndUpdaterExprs[0]); }
4965 void setBase(Expr *Base) { BaseAndUpdaterExprs[0] = Base; }
4970 void setUpdater(Expr *Updater) { BaseAndUpdaterExprs[1] = Updater; }
4999 class ArrayInitLoopExpr : public Expr {
5006 explicit ArrayInitLoopExpr(QualType T, Expr *CommonInit, Expr *ElementInit)
5006 explicit ArrayInitLoopExpr(QualType T, Expr *CommonInit, Expr *ElementInit)
5021 Expr *getSubExpr() const { return cast<Expr>(SubExprs[1]); }
5021 Expr *getSubExpr() const { return cast<Expr>(SubExprs[1]); }
5054 class ArrayInitIndexExpr : public Expr {
5089 class ImplicitValueInitExpr : public Expr {
5116 : public Expr,
5125 ParenListExpr(SourceLocation LParenLoc, ArrayRef<Expr *> Exprs,
5134 ArrayRef<Expr *> Exprs,
5143 Expr *getExpr(unsigned Init) {
5148 const Expr *getExpr(unsigned Init) const {
5152 Expr **getExprs() {
5156 ArrayRef<Expr *> exprs() {
5207 : public Expr,
5253 typename std::conditional<Const, const Expr *, Expr *>::type;
5253 typename std::conditional<Const, const Expr *, Expr *>::type;
5311 return AssociationTy<Const>(cast<Expr>(*E), *TSI,
5327 Expr *ControllingExpr,
5329 ArrayRef<Expr *> AssocExprs, SourceLocation DefaultLoc,
5336 Expr *ControllingExpr,
5338 ArrayRef<Expr *> AssocExprs, SourceLocation DefaultLoc,
5349 Expr *ControllingExpr, ArrayRef<TypeSourceInfo *> AssocTypes,
5350 ArrayRef<Expr *> AssocExprs, SourceLocation DefaultLoc,
5357 Expr *ControllingExpr, ArrayRef<TypeSourceInfo *> AssocTypes,
5358 ArrayRef<Expr *> AssocExprs, SourceLocation DefaultLoc,
5389 Expr *getControllingExpr() {
5390 return cast<Expr>(getTrailingObjects<Stmt *>()[ControllingIndex]);
5392 const Expr *getControllingExpr() const {
5393 return cast<Expr>(getTrailingObjects<Stmt *>()[ControllingIndex]);
5398 Expr *getResultExpr() {
5399 return cast<Expr>(
5402 const Expr *getResultExpr() const {
5403 return cast<Expr>(
5407 ArrayRef<Expr *> getAssocExprs() const {
5422 cast<Expr>(getTrailingObjects<Stmt *>()[AssocExprStartIndex + I]),
5430 cast<Expr>(getTrailingObjects<Stmt *>()[AssocExprStartIndex + I]),
5490 class ExtVectorElementExpr : public Expr {
5495 ExtVectorElementExpr(QualType ty, ExprValueKind VK, Expr *base,
5508 const Expr *getBase() const { return cast<Expr>(Base); }
5508 const Expr *getBase() const { return cast<Expr>(Base); }
5509 Expr *getBase() { return cast<Expr>(Base); }
5509 Expr *getBase() { return cast<Expr>(Base); }
5510 void setBase(Expr *E) { Base = E; }
5551 class BlockExpr : public Expr {
5600 class AsTypeExpr : public Expr {
5610 AsTypeExpr(Expr* SrcExpr, QualType DstType,
5623 Expr *getSrcExpr() const { return cast<Expr>(SrcExpr); }
5623 Expr *getSrcExpr() const { return cast<Expr>(SrcExpr); }
5674 : public Expr,
5675 private llvm::TrailingObjects<PseudoObjectExpr, Expr *> {
5687 Expr **getSubExprsBuffer() { return getTrailingObjects<Expr *>(); }
5687 Expr **getSubExprsBuffer() { return getTrailingObjects<Expr *>(); }
5688 const Expr * const *getSubExprsBuffer() const {
5689 return getTrailingObjects<Expr *>();
5693 Expr *syntactic, ArrayRef<Expr*> semantic,
5693 Expr *syntactic, ArrayRef<Expr*> semantic,
5707 static PseudoObjectExpr *Create(const ASTContext &Context, Expr *syntactic,
5708 ArrayRef<Expr*> semantic,
5717 Expr *getSyntacticForm() { return getSubExprsBuffer()[0]; }
5718 const Expr *getSyntacticForm() const { return getSubExprsBuffer()[0]; }
5728 Expr *getResultExpr() {
5733 const Expr *getResultExpr() const {
5739 typedef Expr * const *semantics_iterator;
5740 typedef const Expr * const *const_semantics_iterator;
5761 Expr *getSemanticExpr(unsigned index) {
5765 const Expr *getSemanticExpr(unsigned index) const {
5807 class AtomicExpr : public Expr {
5829 AtomicExpr(SourceLocation BLoc, ArrayRef<Expr*> args, QualType t,
5839 Expr *getPtr() const {
5840 return cast<Expr>(SubExprs[PTR]);
5842 Expr *getOrder() const {
5843 return cast<Expr>(SubExprs[ORDER]);
5845 Expr *getScope() const {
5847 return cast<Expr>(SubExprs[NumSubExprs - 1]);
5849 Expr *getVal1() const {
5851 return cast<Expr>(SubExprs[ORDER]);
5853 return cast<Expr>(SubExprs[VAL1]);
5855 Expr *getOrderFail() const {
5857 return cast<Expr>(SubExprs[ORDER_FAIL]);
5859 Expr *getVal2() const {
5861 return cast<Expr>(SubExprs[ORDER_FAIL]);
5863 return cast<Expr>(SubExprs[VAL2]);
5865 Expr *getWeak() const {
5867 return cast<Expr>(SubExprs[WEAK]);
5874 Expr **getSubExprs() { return reinterpret_cast<Expr **>(SubExprs); }
5875 const Expr * const *getSubExprs() const {
5936 class TypoExpr : public Expr {
tools/clang/include/clang/AST/ExprCXX.h 89 CXXOperatorCallExpr(OverloadedOperatorKind OpKind, Expr *Fn,
90 ArrayRef<Expr *> Args, QualType Ty, ExprValueKind VK,
98 Create(const ASTContext &Ctx, OverloadedOperatorKind OpKind, Expr *Fn,
99 ArrayRef<Expr *> Args, QualType Ty, ExprValueKind VK,
175 CXXMemberCallExpr(Expr *Fn, ArrayRef<Expr *> Args, QualType Ty,
175 CXXMemberCallExpr(Expr *Fn, ArrayRef<Expr *> Args, QualType Ty,
181 static CXXMemberCallExpr *Create(const ASTContext &Ctx, Expr *Fn,
182 ArrayRef<Expr *> Args, QualType Ty,
192 Expr *getImplicitObjectArgument() const;
232 CUDAKernelCallExpr(Expr *Fn, CallExpr *Config, ArrayRef<Expr *> Args,
232 CUDAKernelCallExpr(Expr *Fn, CallExpr *Config, ArrayRef<Expr *> Args,
239 static CUDAKernelCallExpr *Create(const ASTContext &Ctx, Expr *Fn,
240 CallExpr *Config, ArrayRef<Expr *> Args,
273 class CXXRewrittenBinaryOperator : public Expr {
280 CXXRewrittenBinaryOperator(Expr *SemanticForm, bool IsReversed)
293 Expr *getSemanticForm() { return cast<Expr>(SemanticForm); }
293 Expr *getSemanticForm() { return cast<Expr>(SemanticForm); }
294 const Expr *getSemanticForm() const { return cast<Expr>(SemanticForm); }
294 const Expr *getSemanticForm() const { return cast<Expr>(SemanticForm); }
300 const Expr *LHS;
302 const Expr *RHS;
304 const Expr *InnerBinOp;
314 const Expr *getLHS() const { return getDecomposedForm().LHS; }
315 const Expr *getRHS() const { return getDecomposedForm().RHS; }
368 CastKind kind, Expr *op, unsigned PathSize,
412 CXXStaticCastExpr(QualType ty, ExprValueKind vk, CastKind kind, Expr *op,
427 ExprValueKind VK, CastKind K, Expr *Op,
449 Expr *op, unsigned pathSize, TypeSourceInfo *writtenTy,
463 ExprValueKind VK, CastKind Kind, Expr *Op,
492 Expr *op, unsigned pathSize,
508 Expr *Op, const CXXCastPath *Path,
530 CXXConstCastExpr(QualType ty, ExprValueKind VK, Expr *op,
544 ExprValueKind VK, Expr *Op,
574 UserDefinedLiteral(Expr *Fn, ArrayRef<Expr *> Args, QualType Ty,
574 UserDefinedLiteral(Expr *Fn, ArrayRef<Expr *> Args, QualType Ty,
581 static UserDefinedLiteral *Create(const ASTContext &Ctx, Expr *Fn,
582 ArrayRef<Expr *> Args, QualType Ty,
617 Expr *getCookedLiteral();
618 const Expr *getCookedLiteral() const {
645 class CXXBoolLiteralExpr : public Expr {
683 class CXXNullPtrLiteralExpr : public Expr {
715 class CXXStdInitializerListExpr : public Expr {
725 CXXStdInitializerListExpr(QualType Ty, Expr *SubExpr)
732 Expr *getSubExpr() { return static_cast<Expr*>(SubExpr); }
733 const Expr *getSubExpr() const { return static_cast<const Expr*>(SubExpr); }
764 class CXXTypeidExpr : public Expr {
781 CXXTypeidExpr(QualType Ty, Expr *Operand, SourceRange R)
821 Expr *getExprOperand() const {
826 void setExprOperand(Expr *E) {
863 class MSPropertyRefExpr : public Expr {
864 Expr *BaseExpr;
873 MSPropertyRefExpr(Expr *baseExpr, MSPropertyDecl *decl, bool isArrow,
919 Expr *getBaseExpr() const { return BaseExpr; }
937 class MSPropertySubscriptExpr : public Expr {
945 void setBase(Expr *Base) { SubExprs[BASE_EXPR] = Base; }
946 void setIdx(Expr *Idx) { SubExprs[IDX_EXPR] = Idx; }
949 MSPropertySubscriptExpr(Expr *Base, Expr *Idx, QualType Ty, ExprValueKind VK,
949 MSPropertySubscriptExpr(Expr *Base, Expr *Idx, QualType Ty, ExprValueKind VK,
963 Expr *getBase() { return cast<Expr>(SubExprs[BASE_EXPR]); }
963 Expr *getBase() { return cast<Expr>(SubExprs[BASE_EXPR]); }
964 const Expr *getBase() const { return cast<Expr>(SubExprs[BASE_EXPR]); }
964 const Expr *getBase() const { return cast<Expr>(SubExprs[BASE_EXPR]); }
966 Expr *getIdx() { return cast<Expr>(SubExprs[IDX_EXPR]); }
966 Expr *getIdx() { return cast<Expr>(SubExprs[IDX_EXPR]); }
967 const Expr *getIdx() const { return cast<Expr>(SubExprs[IDX_EXPR]); }
967 const Expr *getIdx() const { return cast<Expr>(SubExprs[IDX_EXPR]); }
1000 class CXXUuidofExpr : public Expr {
1015 CXXUuidofExpr(QualType Ty, Expr *Operand, StringRef UuidStr, SourceRange R)
1046 Expr *getExprOperand() const {
1051 void setExprOperand(Expr *E) {
1097 class CXXThisExpr : public Expr {
1140 class CXXThrowExpr : public Expr {
1151 CXXThrowExpr(Expr *Operand, QualType Ty, SourceLocation Loc,
1162 const Expr *getSubExpr() const { return cast_or_null<Expr>(Operand); }
1162 const Expr *getSubExpr() const { return cast_or_null<Expr>(Operand); }
1163 Expr *getSubExpr() { return cast_or_null<Expr>(Operand); }
1163 Expr *getSubExpr() { return cast_or_null<Expr>(Operand); }
1202 class CXXDefaultArgExpr final : public Expr {
1241 const Expr *getExpr() const { return getParam()->getDefaultArg(); }
1242 Expr *getExpr() { return getParam()->getDefaultArg(); }
1279 class CXXDefaultInitExpr : public Expr {
1307 const Expr *getExpr() const {
1311 Expr *getExpr() {
1373 class CXXBindTemporaryExpr : public Expr {
1377 CXXBindTemporaryExpr(CXXTemporary *temp, Expr* SubExpr)
1390 Expr* SubExpr);
1396 const Expr *getSubExpr() const { return cast<Expr>(SubExpr); }
1396 const Expr *getSubExpr() const { return cast<Expr>(SubExpr); }
1397 Expr *getSubExpr() { return cast<Expr>(SubExpr); }
1397 Expr *getSubExpr() { return cast<Expr>(SubExpr); }
1398 void setSubExpr(Expr *E) { SubExpr = E; }
1422 class CXXConstructExpr : public Expr {
1467 ArrayRef<Expr *> Args, bool HadMultipleCandidates,
1485 CXXConstructorDecl *Ctor, bool Elidable, ArrayRef<Expr *> Args,
1564 Expr **getArgs() { return reinterpret_cast<Expr **>(getTrailingArgs()); }
1565 const Expr *const *getArgs() const {
1573 Expr *getArg(unsigned Arg) {
1577 const Expr *getArg(unsigned Arg) const {
1583 void setArg(unsigned Arg, Expr *ArgExpr) {
1613 class CXXInheritedCtorInitExpr : public Expr {
1696 CastKind kind, Expr *castExpr, unsigned pathSize,
1712 CastKind Kind, Expr *Op,
1760 TypeSourceInfo *TSI, ArrayRef<Expr *> Args,
1771 TypeSourceInfo *TSI, ArrayRef<Expr *> Args,
1818 class LambdaExpr final : public Expr,
1855 ArrayRef<Expr *> CaptureInits, SourceLocation ClosingBrace,
1880 bool ExplicitResultType, ArrayRef<Expr *> CaptureInits,
1945 using capture_init_iterator = Expr **;
1949 using const_capture_init_iterator = Expr *const *;
2053 class CXXScalarValueInitExpr : public Expr {
2101 : public Expr,
2167 bool UsualArrayDeleteWantsSize, ArrayRef<Expr *> PlacementArgs,
2168 SourceRange TypeIdParens, Optional<Expr *> ArraySize,
2169 InitializationStyle InitializationStyle, Expr *Initializer,
2182 bool UsualArrayDeleteWantsSize, ArrayRef<Expr *> PlacementArgs,
2183 SourceRange TypeIdParens, Optional<Expr *> ArraySize,
2184 InitializationStyle InitializationStyle, Expr *Initializer,
2225 Optional<Expr *> getArraySize() {
2228 return cast_or_null<Expr>(getTrailingObjects<Stmt *>()[arraySizeOffset()]);
2230 Optional<const Expr *> getArraySize() const {
2233 return cast_or_null<Expr>(getTrailingObjects<Stmt *>()[arraySizeOffset()]);
2240 Expr **getPlacementArgs() {
2245 Expr *getPlacementArg(unsigned I) {
2249 const Expr *getPlacementArg(unsigned I) const {
2275 Expr *getInitializer() {
2277 ? cast<Expr>(getTrailingObjects<Stmt *>()[initExprOffset()])
2280 const Expr *getInitializer() const {
2282 ? cast<Expr>(getTrailingObjects<Stmt *>()[initExprOffset()])
2359 class CXXDeleteExpr : public Expr {
2371 FunctionDecl *OperatorDelete, Expr *Arg, SourceLocation Loc)
2401 Expr *getArgument() { return cast<Expr>(Argument); }
2401 Expr *getArgument() { return cast<Expr>(Argument); }
2402 const Expr *getArgument() const { return cast<Expr>(Argument); }
2402 const Expr *getArgument() const { return cast<Expr>(Argument); }
2479 class CXXPseudoDestructorExpr : public Expr {
2512 Expr *Base, bool isArrow, SourceLocation OperatorLoc,
2522 Expr *getBase() const { return cast<Expr>(Base); }
2522 Expr *getBase() const { return cast<Expr>(Base); }
2628 : public Expr,
2715 class ArrayTypeTraitExpr : public Expr {
2723 Expr *Dimension;
2739 Expr *dimension, SourceLocation rparen, QualType ty)
2762 Expr *getDimensionExpression() const { return Dimension; }
2785 class ExpressionTraitExpr : public Expr {
2799 Expr* QueriedExpression = nullptr;
2805 Expr *queried, bool value,
2824 Expr *getQueriedExpression() const { return QueriedExpression; }
2844 class OverloadExpr : public Expr {
2904 static FindResult find(Expr *E) {
3156 : public Expr,
3321 ExprWithCleanups(Expr *SubExpr, bool CleanupsHaveSideEffects,
3328 static ExprWithCleanups *Create(const ASTContext &C, Expr *subexpr,
3391 : public Expr,
3392 private llvm::TrailingObjects<CXXUnresolvedConstructExpr, Expr *> {
3406 ArrayRef<Expr *> Args, SourceLocation RParenLoc);
3417 ArrayRef<Expr *> Args,
3449 using arg_iterator = Expr **;
3452 arg_iterator arg_begin() { return getTrailingObjects<Expr *>(); }
3456 using const_arg_iterator = const Expr* const *;
3459 const_arg_iterator arg_begin() const { return getTrailingObjects<Expr *>(); }
3465 Expr *getArg(unsigned I) {
3470 const Expr *getArg(unsigned I) const {
3475 void setArg(unsigned I, Expr *E) {
3512 : public Expr,
3574 CXXDependentScopeMemberExpr(const ASTContext &Ctx, Expr *Base,
3588 Create(const ASTContext &Ctx, Expr *Base, QualType BaseType, bool IsArrow,
3604 return cast<Expr>(Base)->isImplicitCXXThis();
3609 Expr *getBase() const {
3611 return cast<Expr>(Base);
3807 Expr *Base, QualType BaseType, bool IsArrow,
3828 Create(const ASTContext &Context, bool HasUnresolvedUsing, Expr *Base,
3848 Expr *getBase() {
3850 return cast<Expr>(Base);
3852 const Expr *getBase() const {
3854 return cast<Expr>(Base);
3958 class CXXNoexceptExpr : public Expr {
3965 CXXNoexceptExpr(QualType Ty, Expr *Operand, CanThrowResult Val,
3978 Expr *getOperand() const { return static_cast<Expr *>(Operand); }
4015 class PackExpansionExpr : public Expr {
4031 PackExpansionExpr(QualType T, Expr *Pattern, SourceLocation EllipsisLoc,
4044 Expr *getPattern() { return reinterpret_cast<Expr *>(Pattern); }
4047 const Expr *getPattern() const { return reinterpret_cast<Expr *>(Pattern); }
4092 : public Expr,
4209 class SubstNonTypeTemplateParmExpr : public Expr {
4226 Expr *Replacement)
4241 Expr *getReplacement() const { return cast<Expr>(Replacement); }
4241 Expr *getReplacement() const { return cast<Expr>(Replacement); }
4269 class SubstNonTypeTemplateParmPackExpr : public Expr {
4338 : public Expr,
4419 class MaterializeTemporaryExpr : public Expr {
4438 MaterializeTemporaryExpr(QualType T, Expr *Temporary,
4457 Expr *GetTemporaryExpr() const { return static_cast<Expr *>(getTemporary()); }
4535 class CXXFoldExpr : public Expr {
4549 CXXFoldExpr(QualType T, SourceLocation LParenLoc, Expr *LHS,
4550 BinaryOperatorKind Opcode, SourceLocation EllipsisLoc, Expr *RHS,
4563 Expr *getLHS() const { return static_cast<Expr*>(SubExprs[0]); }
4564 Expr *getRHS() const { return static_cast<Expr*>(SubExprs[1]); }
4575 Expr *getPattern() const { return isLeftFold() ? getRHS() : getLHS(); }
4578 Expr *getInit() const { return isLeftFold() ? getLHS() : getRHS(); }
4618 class CoroutineSuspendExpr : public Expr {
4629 CoroutineSuspendExpr(StmtClass SC, SourceLocation KeywordLoc, Expr *Common,
4630 Expr *Ready, Expr *Suspend, Expr *Resume,
4630 Expr *Ready, Expr *Suspend, Expr *Resume,
4630 Expr *Ready, Expr *Suspend, Expr *Resume,
4644 Expr *Common)
4665 Expr *getCommonExpr() const {
4672 Expr *getReadyExpr() const {
4676 Expr *getSuspendExpr() const {
4680 Expr *getResumeExpr() const {
4709 CoawaitExpr(SourceLocation CoawaitLoc, Expr *Operand, Expr *Ready,
4709 CoawaitExpr(SourceLocation CoawaitLoc, Expr *Operand, Expr *Ready,
4710 Expr *Suspend, Expr *Resume, OpaqueValueExpr *OpaqueValue,
4710 Expr *Suspend, Expr *Resume, OpaqueValueExpr *OpaqueValue,
4717 CoawaitExpr(SourceLocation CoawaitLoc, QualType Ty, Expr *Operand,
4726 Expr *getOperand() const {
4741 class DependentCoawaitExpr : public Expr {
4748 DependentCoawaitExpr(SourceLocation KeywordLoc, QualType Ty, Expr *Op,
4766 Expr *getOperand() const { return cast<Expr>(SubExprs[0]); }
4766 Expr *getOperand() const { return cast<Expr>(SubExprs[0]); }
4796 CoyieldExpr(SourceLocation CoyieldLoc, Expr *Operand, Expr *Ready,
4796 CoyieldExpr(SourceLocation CoyieldLoc, Expr *Operand, Expr *Ready,
4797 Expr *Suspend, Expr *Resume, OpaqueValueExpr *OpaqueValue)
4797 Expr *Suspend, Expr *Resume, OpaqueValueExpr *OpaqueValue)
4800 CoyieldExpr(SourceLocation CoyieldLoc, QualType Ty, Expr *Operand)
4805 Expr *getOperand() const {
4829 BuiltinBitCastExpr(QualType T, ExprValueKind VK, CastKind CK, Expr *SrcExpr,
4849 class ConceptSpecializationExpr final : public Expr,
tools/clang/include/clang/AST/ExprObjC.h 50 class ObjCStringLiteral : public Expr {
85 class ObjCBoolLiteralExpr : public Expr {
124 class ObjCBoxedExpr : public Expr {
132 ObjCBoxedExpr(Expr *E, QualType T, ObjCMethodDecl *method,
142 Expr *getSubExpr() { return cast<Expr>(SubExpr); }
142 Expr *getSubExpr() { return cast<Expr>(SubExpr); }
143 const Expr *getSubExpr() const { return cast<Expr>(SubExpr); }
143 const Expr *getSubExpr() const { return cast<Expr>(SubExpr); }
189 : public Expr,
190 private llvm::TrailingObjects<ObjCArrayLiteral, Expr *> {
195 ObjCArrayLiteral(ArrayRef<Expr *> Elements,
207 ArrayRef<Expr *> Elements,
219 Expr **getElements() { return getTrailingObjects<Expr *>(); }
219 Expr **getElements() { return getTrailingObjects<Expr *>(); }
222 const Expr * const *getElements() const {
223 return getTrailingObjects<Expr *>();
230 Expr *getElement(unsigned Index) {
234 const Expr *getElement(unsigned Index) const {
263 Expr *Key;
266 Expr *Value;
285 Expr *Key;
286 Expr *Value;
305 : public Expr,
407 class ObjCEncodeExpr : public Expr {
454 class ObjCSelectorExpr : public Expr {
503 class ObjCProtocolExpr : public Expr {
546 class ObjCIvarRefExpr : public Expr {
563 Expr *base,
580 const Expr *getBase() const { return cast<Expr>(Base); }
580 const Expr *getBase() const { return cast<Expr>(Base); }
581 Expr *getBase() { return cast<Expr>(Base); }
581 Expr *getBase() { return cast<Expr>(Base); }
582 void setBase(Expr * base) { Base = base; }
614 class ObjCPropertyRefExpr : public Expr {
650 SourceLocation l, Expr *base)
672 SourceLocation IdLoc, Expr *Base)
756 const Expr *getBase() const {
757 return cast<Expr>(Receiver.get<Stmt*>());
759 Expr *getBase() {
760 return cast<Expr>(Receiver.get<Stmt*>());
826 void setBase(Expr *Base) { Receiver = Base; }
845 class ObjCSubscriptRefExpr : public Expr {
862 ObjCSubscriptRefExpr(Expr *base, Expr *key, QualType T,
862 ObjCSubscriptRefExpr(Expr *base, Expr *key, QualType T,
890 Expr *getBaseExpr() const { return cast<Expr>(SubExprs[BASE]); }
890 Expr *getBaseExpr() const { return cast<Expr>(SubExprs[BASE]); }
893 Expr *getKeyExpr() const { return cast<Expr>(SubExprs[KEY]); }
893 Expr *getKeyExpr() const { return cast<Expr>(SubExprs[KEY]); }
951 : public Expr,
1012 ArrayRef<Expr *> Args,
1022 ArrayRef<Expr *> Args,
1027 Expr *Receiver,
1032 ArrayRef<Expr *> Args,
1043 void initArgsAndSelLocs(ArrayRef<Expr *> Args,
1081 ArrayRef<Expr *> Args,
1144 ArrayRef<Expr *> Args,
1178 ArrayRef<Expr *> Args,
1208 Expr *Receiver,
1212 ArrayRef<Expr *> Args,
1260 Expr *getInstanceReceiver() {
1266 const Expr *getInstanceReceiver() const {
1272 void setInstanceReceiver(Expr *rec) {
1386 Expr **getArgs() {
1389 const Expr * const *getArgs() const {
1395 Expr *getArg(unsigned Arg) {
1399 const Expr *getArg(unsigned Arg) const {
1405 void setArg(unsigned Arg, Expr *ArgExpr) {
1492 class ObjCIsaExpr : public Expr {
1506 ObjCIsaExpr(Expr *base, bool isarrow, SourceLocation l, SourceLocation oploc,
1517 void setBase(Expr *E) { Base = E; }
1518 Expr *getBase() const { return cast<Expr>(Base); }
1518 Expr *getBase() const { return cast<Expr>(Base); }
1577 class ObjCIndirectCopyRestoreExpr : public Expr {
1593 ObjCIndirectCopyRestoreExpr(Expr *operand, QualType type, bool shouldCopy)
1602 Expr *getSubExpr() { return cast<Expr>(Operand); }
1602 Expr *getSubExpr() { return cast<Expr>(Operand); }
1603 const Expr *getSubExpr() const { return cast<Expr>(Operand); }
1603 const Expr *getSubExpr() const { return cast<Expr>(Operand); }
1653 TypeSourceInfo *TSInfo, Expr *Operand)
1699 class ObjCAvailabilityCheckExpr : public Expr {
tools/clang/include/clang/AST/ExprOpenMP.h 44 class OMPArraySectionExpr : public Expr {
51 OMPArraySectionExpr(Expr *Base, Expr *LowerBound, Expr *Length, QualType Type,
51 OMPArraySectionExpr(Expr *Base, Expr *LowerBound, Expr *Length, QualType Type,
51 OMPArraySectionExpr(Expr *Base, Expr *LowerBound, Expr *Length, QualType Type,
81 Expr *getBase() { return cast<Expr>(SubExprs[BASE]); }
81 Expr *getBase() { return cast<Expr>(SubExprs[BASE]); }
82 const Expr *getBase() const { return cast<Expr>(SubExprs[BASE]); }
82 const Expr *getBase() const { return cast<Expr>(SubExprs[BASE]); }
84 void setBase(Expr *E) { SubExprs[BASE] = E; }
87 static QualType getBaseOriginalType(const Expr *Base);
90 Expr *getLowerBound() { return cast_or_null<Expr>(SubExprs[LOWER_BOUND]); }
90 Expr *getLowerBound() { return cast_or_null<Expr>(SubExprs[LOWER_BOUND]); }
91 const Expr *getLowerBound() const {
92 return cast_or_null<Expr>(SubExprs[LOWER_BOUND]);
95 void setLowerBound(Expr *E) { SubExprs[LOWER_BOUND] = E; }
98 Expr *getLength() { return cast_or_null<Expr>(SubExprs[LENGTH]); }
98 Expr *getLength() { return cast_or_null<Expr>(SubExprs[LENGTH]); }
99 const Expr *getLength() const { return cast_or_null<Expr>(SubExprs[LENGTH]); }
99 const Expr *getLength() const { return cast_or_null<Expr>(SubExprs[LENGTH]); }
101 void setLength(Expr *E) { SubExprs[LENGTH] = E; }
tools/clang/include/clang/AST/NSAPI.h 60 bool isNSUTF8StringEncodingConstant(const Expr *E) const {
66 bool isNSASCIIStringEncodingConstant(const Expr *E) const {
233 bool isObjCEnumerator(const Expr *E,
tools/clang/include/clang/AST/OSLog.h 73 const Expr *TheExpr = nullptr;
80 OSLogBufferItem(Kind kind, const Expr *expr, CharUnits size, unsigned flags,
104 const Expr *getExpr() const { return TheExpr; }
tools/clang/include/clang/AST/OpenMPClause.h 147 Expr *PostUpdate = nullptr;
155 void setPostUpdateExpr(Expr *S) { PostUpdate = S; }
159 const Expr *getPostUpdateExpr() const { return PostUpdate; }
162 Expr *getPostUpdateExpr() { return PostUpdate; }
207 MutableArrayRef<Expr *> getVarRefs() {
208 return MutableArrayRef<Expr *>(
209 static_cast<T *>(this)->template getTrailingObjects<Expr *>(), NumVars);
213 void setVarRefs(ArrayRef<Expr *> VL) {
217 static_cast<T *>(this)->template getTrailingObjects<Expr *>());
221 using varlist_iterator = MutableArrayRef<Expr *>::iterator;
222 using varlist_const_iterator = ArrayRef<const Expr *>::iterator;
248 ArrayRef<const Expr *> getVarRefs() const {
250 static_cast<const T *>(this)->template getTrailingObjects<Expr *>(),
273 void setAllocator(Expr *A) { Allocator = A; }
282 OMPAllocatorClause(Expr *A, SourceLocation StartLoc, SourceLocation LParenLoc,
298 Expr *getAllocator() const { return cast_or_null<Expr>(Allocator); }
298 Expr *getAllocator() const { return cast_or_null<Expr>(Allocator); }
327 private llvm::TrailingObjects<OMPAllocateClause, Expr *> {
334 Expr *Allocator = nullptr;
347 Expr *Allocator, SourceLocation ColonLoc,
364 void setAllocator(Expr *A) { Allocator = A; }
377 SourceLocation LParenLoc, Expr *Allocator,
379 SourceLocation EndLoc, ArrayRef<Expr *> VL);
382 Expr *getAllocator() const { return Allocator; }
441 void setCondition(Expr *Cond) { Condition = Cond; }
465 OMPIfClause(OpenMPDirectiveKind NameModifier, Expr *Cond, Stmt *HelperCond,
490 Expr *getCondition() const { return cast_or_null<Expr>(Condition); }
490 Expr *getCondition() const { return cast_or_null<Expr>(Condition); }
532 void setCondition(Expr *Cond) { Condition = Cond; }
544 OMPFinalClause(Expr *Cond, Stmt *HelperCond,
564 Expr *getCondition() const { return cast_or_null<Expr>(Condition); }
564 Expr *getCondition() const { return cast_or_null<Expr>(Condition); }
601 void setNumThreads(Expr *NThreads) { NumThreads = NThreads; }
613 OMPNumThreadsClause(Expr *NumThreads, Stmt *HelperNumThreads,
635 Expr *getNumThreads() const { return cast_or_null<Expr>(NumThreads); }
635 Expr *getNumThreads() const { return cast_or_null<Expr>(NumThreads); }
677 void setSafelen(Expr *Len) { Safelen = Len; }
685 OMPSafelenClause(Expr *Len, SourceLocation StartLoc, SourceLocation LParenLoc,
701 Expr *getSafelen() const { return cast_or_null<Expr>(Safelen); }
701 Expr *getSafelen() const { return cast_or_null<Expr>(Safelen); }
742 void setSimdlen(Expr *Len) { Simdlen = Len; }
750 OMPSimdlenClause(Expr *Len, SourceLocation StartLoc, SourceLocation LParenLoc,
766 Expr *getSimdlen() const { return cast_or_null<Expr>(Simdlen); }
766 Expr *getSimdlen() const { return cast_or_null<Expr>(Simdlen); }
807 void setNumForLoops(Expr *Num) { NumForLoops = Num; }
816 OMPCollapseClause(Expr *Num, SourceLocation StartLoc,
832 Expr *getNumForLoops() const { return cast_or_null<Expr>(NumForLoops); }
832 Expr *getNumForLoops() const { return cast_or_null<Expr>(NumForLoops); }
1301 Expr *ChunkSize = nullptr;
1362 void setChunkSize(Expr *E) { ChunkSize = E; }
1383 Expr *ChunkSize, Stmt *HelperChunkSize,
1437 Expr *getChunkSize() { return ChunkSize; }
1440 const Expr *getChunkSize() const { return ChunkSize; }
1473 private llvm::TrailingObjects<OMPOrderedClause, Expr *> {
1493 OMPOrderedClause(Expr *Num, unsigned NumLoops, SourceLocation StartLoc,
1504 void setNumForLoops(Expr *Num) { NumForLoops = Num; }
1514 static OMPOrderedClause *Create(const ASTContext &C, Expr *Num,
1529 Expr *getNumForLoops() const { return cast_or_null<Expr>(NumForLoops); }
1529 Expr *getNumForLoops() const { return cast_or_null<Expr>(NumForLoops); }
1532 void setLoopNumIterations(unsigned NumLoop, Expr *NumIterations);
1534 ArrayRef<Expr *> getLoopNumIterations() const;
1537 void setLoopCounter(unsigned NumLoop, Expr *Counter);
1539 Expr *getLoopCounter(unsigned NumLoop);
1540 const Expr *getLoopCounter(unsigned NumLoop) const;
1884 private llvm::TrailingObjects<OMPPrivateClause, Expr *> {
1911 void setPrivateCopies(ArrayRef<Expr *> VL);
1915 MutableArrayRef<Expr *> getPrivateCopies() {
1918 ArrayRef<const Expr *> getPrivateCopies() const {
1933 SourceLocation EndLoc, ArrayRef<Expr *> VL,
1934 ArrayRef<Expr *> PrivateVL);
1942 using private_copies_iterator = MutableArrayRef<Expr *>::iterator;
1943 using private_copies_const_iterator = ArrayRef<const Expr *>::iterator;
1991 private llvm::TrailingObjects<OMPFirstprivateClause, Expr *> {
2020 void setPrivateCopies(ArrayRef<Expr *> VL);
2024 MutableArrayRef<Expr *> getPrivateCopies() {
2027 ArrayRef<const Expr *> getPrivateCopies() const {
2034 void setInits(ArrayRef<Expr *> VL);
2038 MutableArrayRef<Expr *> getInits() {
2041 ArrayRef<const Expr *> getInits() const {
2061 SourceLocation EndLoc, ArrayRef<Expr *> VL, ArrayRef<Expr *> PrivateVL,
2061 SourceLocation EndLoc, ArrayRef<Expr *> VL, ArrayRef<Expr *> PrivateVL,
2062 ArrayRef<Expr *> InitVL, Stmt *PreInit);
2070 using private_copies_iterator = MutableArrayRef<Expr *>::iterator;
2071 using private_copies_const_iterator = ArrayRef<const Expr *>::iterator;
2085 using inits_iterator = MutableArrayRef<Expr *>::iterator;
2086 using inits_const_iterator = ArrayRef<const Expr *>::iterator;
2132 private llvm::TrailingObjects<OMPLastprivateClause, Expr *> {
2176 MutableArrayRef<Expr *> getPrivateCopies() {
2179 ArrayRef<const Expr *> getPrivateCopies() const {
2187 void setSourceExprs(ArrayRef<Expr *> SrcExprs);
2190 MutableArrayRef<Expr *> getSourceExprs() {
2193 ArrayRef<const Expr *> getSourceExprs() const {
2201 void setDestinationExprs(ArrayRef<Expr *> DstExprs);
2204 MutableArrayRef<Expr *> getDestinationExprs() {
2207 ArrayRef<const Expr *> getDestinationExprs() const {
2214 void setAssignmentOps(ArrayRef<Expr *> AssignmentOps);
2217 MutableArrayRef<Expr *> getAssignmentOps() {
2220 ArrayRef<const Expr *> getAssignmentOps() const {
2251 SourceLocation EndLoc, ArrayRef<Expr *> VL, ArrayRef<Expr *> SrcExprs,
2251 SourceLocation EndLoc, ArrayRef<Expr *> VL, ArrayRef<Expr *> SrcExprs,
2252 ArrayRef<Expr *> DstExprs, ArrayRef<Expr *> AssignmentOps,
2252 ArrayRef<Expr *> DstExprs, ArrayRef<Expr *> AssignmentOps,
2253 Stmt *PreInit, Expr *PostUpdate);
2261 using helper_expr_iterator = MutableArrayRef<Expr *>::iterator;
2262 using helper_expr_const_iterator = ArrayRef<const Expr *>::iterator;
2269 void setPrivateCopies(ArrayRef<Expr *> PrivateCopies);
2341 private llvm::TrailingObjects<OMPSharedClause, Expr *> {
2374 SourceLocation EndLoc, ArrayRef<Expr *> VL);
2415 private llvm::TrailingObjects<OMPReductionClause, Expr *> {
2468 void setPrivates(ArrayRef<Expr *> Privates);
2471 MutableArrayRef<Expr *> getPrivates() {
2474 ArrayRef<const Expr *> getPrivates() const {
2481 void setLHSExprs(ArrayRef<Expr *> LHSExprs);
2484 MutableArrayRef<Expr *> getLHSExprs() {
2487 ArrayRef<const Expr *> getLHSExprs() const {
2496 void setRHSExprs(ArrayRef<Expr *> RHSExprs);
2499 MutableArrayRef<Expr *> getRHSExprs() {
2502 ArrayRef<const Expr *> getRHSExprs() const {
2510 void setReductionOps(ArrayRef<Expr *> ReductionOps);
2513 MutableArrayRef<Expr *> getReductionOps() {
2516 ArrayRef<const Expr *> getReductionOps() const {
2555 SourceLocation ColonLoc, SourceLocation EndLoc, ArrayRef<Expr *> VL,
2557 const DeclarationNameInfo &NameInfo, ArrayRef<Expr *> Privates,
2558 ArrayRef<Expr *> LHSExprs, ArrayRef<Expr *> RHSExprs,
2558 ArrayRef<Expr *> LHSExprs, ArrayRef<Expr *> RHSExprs,
2559 ArrayRef<Expr *> ReductionOps, Stmt *PreInit, Expr *PostUpdate);
2559 ArrayRef<Expr *> ReductionOps, Stmt *PreInit, Expr *PostUpdate);
2576 using helper_expr_iterator = MutableArrayRef<Expr *>::iterator;
2577 using helper_expr_const_iterator = ArrayRef<const Expr *>::iterator;
2651 private llvm::TrailingObjects<OMPTaskReductionClause, Expr *> {
2703 void setPrivates(ArrayRef<Expr *> Privates);
2706 MutableArrayRef<Expr *> getPrivates() {
2709 ArrayRef<const Expr *> getPrivates() const {
2716 void setLHSExprs(ArrayRef<Expr *> LHSExprs);
2719 MutableArrayRef<Expr *> getLHSExprs() {
2722 ArrayRef<const Expr *> getLHSExprs() const {
2730 void setRHSExprs(ArrayRef<Expr *> RHSExprs);
2733 MutableArrayRef<Expr *> getRHSExprs() {
2736 ArrayRef<const Expr *> getRHSExprs() const {
2744 void setReductionOps(ArrayRef<Expr *> ReductionOps);
2747 MutableArrayRef<Expr *> getReductionOps() {
2750 ArrayRef<const Expr *> getReductionOps() const {
2789 SourceLocation ColonLoc, SourceLocation EndLoc, ArrayRef<Expr *> VL,
2791 const DeclarationNameInfo &NameInfo, ArrayRef<Expr *> Privates,
2792 ArrayRef<Expr *> LHSExprs, ArrayRef<Expr *> RHSExprs,
2792 ArrayRef<Expr *> LHSExprs, ArrayRef<Expr *> RHSExprs,
2793 ArrayRef<Expr *> ReductionOps, Stmt *PreInit, Expr *PostUpdate);
2793 ArrayRef<Expr *> ReductionOps, Stmt *PreInit, Expr *PostUpdate);
2810 using helper_expr_iterator = MutableArrayRef<Expr *>::iterator;
2811 using helper_expr_const_iterator = ArrayRef<const Expr *>::iterator;
2882 private llvm::TrailingObjects<OMPInReductionClause, Expr *> {
2934 void setPrivates(ArrayRef<Expr *> Privates);
2937 MutableArrayRef<Expr *> getPrivates() {
2940 ArrayRef<const Expr *> getPrivates() const {
2947 void setLHSExprs(ArrayRef<Expr *> LHSExprs);
2950 MutableArrayRef<Expr *> getLHSExprs() {
2953 ArrayRef<const Expr *> getLHSExprs() const {
2961 void setRHSExprs(ArrayRef<Expr *> RHSExprs);
2964 MutableArrayRef<Expr *> getRHSExprs() {
2967 ArrayRef<const Expr *> getRHSExprs() const {
2975 void setReductionOps(ArrayRef<Expr *> ReductionOps);
2978 MutableArrayRef<Expr *> getReductionOps() {
2981 ArrayRef<const Expr *> getReductionOps() const {
2986 void setTaskgroupDescriptors(ArrayRef<Expr *> ReductionOps);
2989 MutableArrayRef<Expr *> getTaskgroupDescriptors() {
2992 ArrayRef<const Expr *> getTaskgroupDescriptors() const {
3033 SourceLocation ColonLoc, SourceLocation EndLoc, ArrayRef<Expr *> VL,
3035 const DeclarationNameInfo &NameInfo, ArrayRef<Expr *> Privates,
3036 ArrayRef<Expr *> LHSExprs, ArrayRef<Expr *> RHSExprs,
3036 ArrayRef<Expr *> LHSExprs, ArrayRef<Expr *> RHSExprs,
3037 ArrayRef<Expr *> ReductionOps, ArrayRef<Expr *> TaskgroupDescriptors,
3037 ArrayRef<Expr *> ReductionOps, ArrayRef<Expr *> TaskgroupDescriptors,
3038 Stmt *PreInit, Expr *PostUpdate);
3055 using helper_expr_iterator = MutableArrayRef<Expr *>::iterator;
3056 using helper_expr_const_iterator = ArrayRef<const Expr *>::iterator;
3138 private llvm::TrailingObjects<OMPLinearClause, Expr *> {
3153 void setStep(Expr *Step) { *(getFinals().end()) = Step; }
3156 void setCalcStep(Expr *CalcStep) { *(getFinals().end() + 1) = CalcStep; }
3195 MutableArrayRef<Expr *> getPrivates() {
3198 ArrayRef<const Expr *> getPrivates() const {
3202 MutableArrayRef<Expr *> getInits() {
3205 ArrayRef<const Expr *> getInits() const {
3210 MutableArrayRef<Expr *> getUpdates() {
3213 ArrayRef<const Expr *> getUpdates() const {
3218 MutableArrayRef<Expr *> getFinals() {
3221 ArrayRef<const Expr *> getFinals() const {
3226 MutableArrayRef<Expr *> getUsedExprs() {
3229 ArrayRef<const Expr *> getUsedExprs() const {
3235 void setPrivates(ArrayRef<Expr *> PL);
3239 void setInits(ArrayRef<Expr *> IL);
3264 SourceLocation ColonLoc, SourceLocation EndLoc, ArrayRef<Expr *> VL,
3265 ArrayRef<Expr *> PL, ArrayRef<Expr *> IL, Expr *Step, Expr *CalcStep,
3265 ArrayRef<Expr *> PL, ArrayRef<Expr *> IL, Expr *Step, Expr *CalcStep,
3265 ArrayRef<Expr *> PL, ArrayRef<Expr *> IL, Expr *Step, Expr *CalcStep,
3265 ArrayRef<Expr *> PL, ArrayRef<Expr *> IL, Expr *Step, Expr *CalcStep,
3266 Stmt *PreInit, Expr *PostUpdate);
3293 Expr *getStep() { return *(getFinals().end()); }
3296 const Expr *getStep() const { return *(getFinals().end()); }
3299 Expr *getCalcStep() { return *(getFinals().end() + 1); }
3302 const Expr *getCalcStep() const { return *(getFinals().end() + 1); }
3306 void setUpdates(ArrayRef<Expr *> UL);
3310 void setFinals(ArrayRef<Expr *> FL);
3313 void setUsedExprs(ArrayRef<Expr *> UE);
3315 using privates_iterator = MutableArrayRef<Expr *>::iterator;
3316 using privates_const_iterator = ArrayRef<const Expr *>::iterator;
3328 using inits_iterator = MutableArrayRef<Expr *>::iterator;
3329 using inits_const_iterator = ArrayRef<const Expr *>::iterator;
3341 using updates_iterator = MutableArrayRef<Expr *>::iterator;
3342 using updates_const_iterator = ArrayRef<const Expr *>::iterator;
3354 using finals_iterator = MutableArrayRef<Expr *>::iterator;
3355 using finals_const_iterator = ArrayRef<const Expr *>::iterator;
3367 using used_expressions_iterator = MutableArrayRef<Expr *>::iterator;
3368 using used_expressions_const_iterator = ArrayRef<const Expr *>::iterator;
3414 private llvm::TrailingObjects<OMPAlignedClause, Expr *> {
3423 void setAlignment(Expr *A) { *varlist_end() = A; }
3460 SourceLocation EndLoc, ArrayRef<Expr *> VL,
3461 Expr *A);
3476 Expr *getAlignment() { return *varlist_end(); }
3479 const Expr *getAlignment() const { return *varlist_end(); }
3512 private llvm::TrailingObjects<OMPCopyinClause, Expr *> {
3552 void setSourceExprs(ArrayRef<Expr *> SrcExprs);
3555 MutableArrayRef<Expr *> getSourceExprs() {
3558 ArrayRef<const Expr *> getSourceExprs() const {
3565 void setDestinationExprs(ArrayRef<Expr *> DstExprs);
3568 MutableArrayRef<Expr *> getDestinationExprs() {
3571 ArrayRef<const Expr *> getDestinationExprs() const {
3579 void setAssignmentOps(ArrayRef<Expr *> AssignmentOps);
3582 MutableArrayRef<Expr *> getAssignmentOps() {
3585 ArrayRef<const Expr *> getAssignmentOps() const {
3613 SourceLocation EndLoc, ArrayRef<Expr *> VL, ArrayRef<Expr *> SrcExprs,
3613 SourceLocation EndLoc, ArrayRef<Expr *> VL, ArrayRef<Expr *> SrcExprs,
3614 ArrayRef<Expr *> DstExprs, ArrayRef<Expr *> AssignmentOps);
3614 ArrayRef<Expr *> DstExprs, ArrayRef<Expr *> AssignmentOps);
3622 using helper_expr_iterator = MutableArrayRef<Expr *>::iterator;
3623 using helper_expr_const_iterator = ArrayRef<const Expr *>::iterator;
3689 private llvm::TrailingObjects<OMPCopyprivateClause, Expr *> {
3716 void setSourceExprs(ArrayRef<Expr *> SrcExprs);
3719 MutableArrayRef<Expr *> getSourceExprs() {
3722 ArrayRef<const Expr *> getSourceExprs() const {
3729 void setDestinationExprs(ArrayRef<Expr *> DstExprs);
3732 MutableArrayRef<Expr *> getDestinationExprs() {
3735 ArrayRef<const Expr *> getDestinationExprs() const {
3743 void setAssignmentOps(ArrayRef<Expr *> AssignmentOps);
3746 MutableArrayRef<Expr *> getAssignmentOps() {
3749 ArrayRef<const Expr *> getAssignmentOps() const {
3776 SourceLocation EndLoc, ArrayRef<Expr *> VL, ArrayRef<Expr *> SrcExprs,
3776 SourceLocation EndLoc, ArrayRef<Expr *> VL, ArrayRef<Expr *> SrcExprs,
3777 ArrayRef<Expr *> DstExprs, ArrayRef<Expr *> AssignmentOps);
3777 ArrayRef<Expr *> DstExprs, ArrayRef<Expr *> AssignmentOps);
3785 using helper_expr_iterator = MutableArrayRef<Expr *>::iterator;
3786 using helper_expr_const_iterator = ArrayRef<const Expr *>::iterator;
3856 private llvm::TrailingObjects<OMPFlushClause, Expr *> {
3889 ArrayRef<Expr *> VL);
3929 private llvm::TrailingObjects<OMPDependClause, Expr *> {
3997 ArrayRef<Expr *> VL, unsigned NumLoops);
4022 void setLoopData(unsigned NumLoop, Expr *Cnt);
4025 Expr *getLoopData(unsigned NumLoop);
4026 const Expr *getLoopData(unsigned NumLoop) const;
4070 void setDevice(Expr *E) { Device = E; }
4081 OMPDeviceClause(Expr *E, Stmt *HelperE, OpenMPDirectiveKind CaptureRegion,
4101 Expr *getDevice() { return cast<Expr>(Device); }
4101 Expr *getDevice() { return cast<Expr>(Device); }
4104 Expr *getDevice() const { return cast<Expr>(Device); }
4104 Expr *getDevice() const { return cast<Expr>(Device); }
4213 Expr *AssociatedExpression = nullptr;
4222 explicit MappableComponent(Expr *AssociatedExpression,
4230 Expr *getAssociatedExpression() const { return AssociatedExpression; }
4525 MutableArrayRef<Expr *> getUDMapperRefs() {
4526 return llvm::makeMutableArrayRef<Expr *>(
4527 static_cast<T *>(this)->template getTrailingObjects<Expr *>() +
4534 ArrayRef<Expr *> getUDMapperRefs() const {
4536 static_cast<T *>(this)->template getTrailingObjects<Expr *>() +
4543 void setUDMapperRefs(ArrayRef<Expr *> DMDs) {
4772 using mapperlist_iterator = MutableArrayRef<Expr *>::iterator;
4773 using mapperlist_const_iterator = ArrayRef<const Expr *>::iterator;
4804 OMPMapClause, Expr *, ValueDecl *, unsigned,
4813 size_t numTrailingObjects(OverloadToken<Expr *>) const {
4956 ArrayRef<Expr *> Vars, ArrayRef<ValueDecl *> Declarations,
4958 ArrayRef<Expr *> UDMapperRefs,
5070 void setNumTeams(Expr *E) { NumTeams = E; }
5082 OMPNumTeamsClause(Expr *E, Stmt *HelperE, OpenMPDirectiveKind CaptureRegion,
5102 Expr *getNumTeams() { return cast<Expr>(NumTeams); }
5102 Expr *getNumTeams() { return cast<Expr>(NumTeams); }
5105 Expr *getNumTeams() const { return cast<Expr>(NumTeams); }
5105 Expr *getNumTeams() const { return cast<Expr>(NumTeams); }
5145 void setThreadLimit(Expr *E) { ThreadLimit = E; }
5157 OMPThreadLimitClause(Expr *E, Stmt *HelperE,
5178 Expr *getThreadLimit() { return cast<Expr>(ThreadLimit); }
5178 Expr *getThreadLimit() { return cast<Expr>(ThreadLimit); }
5181 Expr *getThreadLimit() const { return cast<Expr>(ThreadLimit); }
5181 Expr *getThreadLimit() const { return cast<Expr>(ThreadLimit); }
5221 void setPriority(Expr *E) { Priority = E; }
5233 OMPPriorityClause(Expr *Priority, Stmt *HelperPriority,
5253 Expr *getPriority() { return cast<Expr>(Priority); }
5253 Expr *getPriority() { return cast<Expr>(Priority); }
5256 Expr *getPriority() const { return cast<Expr>(Priority); }
5256 Expr *getPriority() const { return cast<Expr>(Priority); }
5293 void setGrainsize(Expr *Size) { Grainsize = Size; }
5304 OMPGrainsizeClause(Expr *Size, Stmt *HelperSize,
5324 Expr *getGrainsize() const { return cast_or_null<Expr>(Grainsize); }
5324 Expr *getGrainsize() const { return cast_or_null<Expr>(Grainsize); }
5400 void setNumTasks(Expr *Size) { NumTasks = Size; }
5411 OMPNumTasksClause(Expr *Size, Stmt *HelperSize,
5431 Expr *getNumTasks() const { return cast_or_null<Expr>(NumTasks); }
5431 Expr *getNumTasks() const { return cast_or_null<Expr>(NumTasks); }
5467 void setHint(Expr *H) { Hint = H; }
5476 OMPHintClause(Expr *Hint, SourceLocation StartLoc, SourceLocation LParenLoc,
5491 Expr *getHint() const { return cast_or_null<Expr>(Hint); }
5491 Expr *getHint() const { return cast_or_null<Expr>(Hint); }
5535 Expr *ChunkSize = nullptr;
5560 void setChunkSize(Expr *E) { ChunkSize = E; }
5577 OpenMPDistScheduleClauseKind Kind, Expr *ChunkSize,
5603 Expr *getChunkSize() { return ChunkSize; }
5606 const Expr *getChunkSize() const { return ChunkSize; }
5752 OMPToClause, Expr *, ValueDecl *, unsigned,
5791 size_t numTrailingObjects(OverloadToken<Expr *>) const {
5819 ArrayRef<Expr *> Vars,
5822 ArrayRef<Expr *> UDMapperRefs,
5870 OMPFromClause, Expr *, ValueDecl *, unsigned,
5909 size_t numTrailingObjects(OverloadToken<Expr *>) const {
5937 ArrayRef<Expr *> Vars,
5940 ArrayRef<Expr *> UDMapperRefs,
5988 OMPUseDevicePtrClause, Expr *, ValueDecl *, unsigned,
6022 size_t numTrailingObjects(OverloadToken<Expr *>) const {
6035 void setPrivateCopies(ArrayRef<Expr *> VL);
6039 MutableArrayRef<Expr *> getPrivateCopies() {
6042 ArrayRef<const Expr *> getPrivateCopies() const {
6049 void setInits(ArrayRef<Expr *> VL);
6053 MutableArrayRef<Expr *> getInits() {
6056 ArrayRef<const Expr *> getInits() const {
6074 ArrayRef<Expr *> Vars, ArrayRef<Expr *> PrivateVars,
6074 ArrayRef<Expr *> Vars, ArrayRef<Expr *> PrivateVars,
6075 ArrayRef<Expr *> Inits, ArrayRef<ValueDecl *> Declarations,
6089 using private_copies_iterator = MutableArrayRef<Expr *>::iterator;
6090 using private_copies_const_iterator = ArrayRef<const Expr *>::iterator;
6105 using inits_iterator = MutableArrayRef<Expr *>::iterator;
6106 using inits_const_iterator = ArrayRef<const Expr *>::iterator;
6151 OMPIsDevicePtrClause, Expr *, ValueDecl *, unsigned,
6185 size_t numTrailingObjects(OverloadToken<Expr *>) const {
6207 ArrayRef<Expr *> Vars, ArrayRef<ValueDecl *> Declarations,
tools/clang/include/clang/AST/ParentMap.h 58 bool isConsumedExpr(Expr *E) const;
60 bool isConsumedExpr(const Expr *E) const {
tools/clang/include/clang/AST/RecursiveASTVisitor.h 298 Expr *Init);
916 Expr *Init) {
1639 if (Expr *RequiresClause = TPL->getRequiresClause()) {
3066 for (auto *E : Node->varlists()) {
3075 for (auto *E : C->private_copies()) {
3086 for (auto *E : C->private_copies()) {
3089 for (auto *E : C->inits()) {
3100 for (auto *E : C->private_copies()) {
3103 for (auto *E : C->source_exprs()) {
3106 for (auto *E : C->destination_exprs()) {
3109 for (auto *E : C->assignment_ops()) {
3127 for (auto *E : C->privates()) {
3130 for (auto *E : C->inits()) {
3133 for (auto *E : C->updates()) {
3136 for (auto *E : C->finals()) {
3152 for (auto *E : C->source_exprs()) {
3155 for (auto *E : C->destination_exprs()) {
3158 for (auto *E : C->assignment_ops()) {
3168 for (auto *E : C->source_exprs()) {
3171 for (auto *E : C->destination_exprs()) {
3174 for (auto *E : C->assignment_ops()) {
3187 for (auto *E : C->privates()) {
3190 for (auto *E : C->lhs_exprs()) {
3193 for (auto *E : C->rhs_exprs()) {
3196 for (auto *E : C->reduction_ops()) {
3209 for (auto *E : C->privates()) {
3212 for (auto *E : C->lhs_exprs()) {
3215 for (auto *E : C->rhs_exprs()) {
3218 for (auto *E : C->reduction_ops()) {
3231 for (auto *E : C->privates()) {
3234 for (auto *E : C->lhs_exprs()) {
3237 for (auto *E : C->rhs_exprs()) {
3240 for (auto *E : C->reduction_ops()) {
3243 for (auto *E : C->taskgroup_descriptors())
tools/clang/include/clang/AST/SelectorLocationsKind.h 47 ArrayRef<Expr *> Args,
59 ArrayRef<Expr *> Args,
tools/clang/include/clang/AST/Stmt.h 1053 : llvm::iterator_adaptor_base<CastIterator<T, TPtr, StmtPtr>, StmtPtr *,
1061 return cast_or_null<T>(*this->I);
1069 using ExprIterator = CastIterator<Expr>;
1070 using ConstExprIterator = ConstCastIterator<Expr>;
1525 CaseStmt(Expr *lhs, Expr *rhs, SourceLocation caseLoc,
1525 CaseStmt(Expr *lhs, Expr *rhs, SourceLocation caseLoc,
1547 static CaseStmt *Create(const ASTContext &Ctx, Expr *lhs, Expr *rhs,
1547 static CaseStmt *Create(const ASTContext &Ctx, Expr *lhs, Expr *rhs,
1577 Expr *getLHS() {
1581 const Expr *getLHS() const {
1585 void setLHS(Expr *Val) {
1589 Expr *getRHS() {
1595 const Expr *getRHS() const {
1601 void setRHS(Expr *Val) {
1706 const Expr *getExprStmt() const;
1707 Expr *getExprStmt() {
1871 VarDecl *Var, Expr *Cond, Stmt *Then, SourceLocation EL, Stmt *Else);
1879 bool IsConstexpr, Stmt *Init, VarDecl *Var, Expr *Cond,
1897 Expr *getCond() {
1901 const Expr *getCond() const {
1905 void setCond(Expr *Cond) {
2066 SwitchStmt(const ASTContext &Ctx, Stmt *Init, VarDecl *Var, Expr *Cond);
2074 Expr *Cond);
2087 Expr *getCond() {
2091 const Expr *getCond() const {
2095 void setCond(Expr *Cond) {
2241 WhileStmt(const ASTContext &Ctx, VarDecl *Var, Expr *Cond, Stmt *Body,
2249 static WhileStmt *Create(const ASTContext &Ctx, VarDecl *Var, Expr *Cond,
2259 Expr *getCond() {
2263 const Expr *getCond() const {
2267 void setCond(Expr *Cond) {
2345 DoStmt(Stmt *Body, Expr *Cond, SourceLocation DL, SourceLocation WL,
2356 Expr *getCond() { return reinterpret_cast<Expr *>(SubExprs[COND]); }
2357 const Expr *getCond() const {
2361 void setCond(Expr *Cond) { SubExprs[COND] = reinterpret_cast<Stmt *>(Cond); }
2400 ForStmt(const ASTContext &C, Stmt *Init, Expr *Cond, VarDecl *condVar,
2401 Expr *Inc, Stmt *Body, SourceLocation FL, SourceLocation LP,
2426 Expr *getCond() { return reinterpret_cast<Expr*>(SubExprs[COND]); }
2427 Expr *getInc() { return reinterpret_cast<Expr*>(SubExprs[INC]); }
2431 const Expr *getCond() const { return reinterpret_cast<Expr*>(SubExprs[COND]);}
2432 const Expr *getInc() const { return reinterpret_cast<Expr*>(SubExprs[INC]); }
2436 void setCond(Expr *E) { SubExprs[COND] = reinterpret_cast<Stmt*>(E); }
2437 void setInc(Expr *E) { SubExprs[INC] = reinterpret_cast<Stmt*>(E); }
2509 IndirectGotoStmt(SourceLocation gotoLoc, SourceLocation starLoc, Expr *target)
2524 Expr *getTarget() { return reinterpret_cast<Expr *>(Target); }
2525 const Expr *getTarget() const {
2528 void setTarget(Expr *E) { Target = reinterpret_cast<Stmt *>(E); }
2639 ReturnStmt(SourceLocation RL, Expr *E, const VarDecl *NRVOCandidate);
2646 static ReturnStmt *Create(const ASTContext &Ctx, SourceLocation RL, Expr *E,
2653 Expr *getRetValue() { return reinterpret_cast<Expr *>(RetExpr); }
2654 const Expr *getRetValue() const { return reinterpret_cast<Expr *>(RetExpr); }
2655 void setRetValue(Expr *E) { RetExpr = reinterpret_cast<Stmt *>(E); }
2766 const Expr *getOutputExpr(unsigned i) const;
2780 const Expr *getInputExpr(unsigned i) const;
2877 IdentifierInfo **names, StringLiteral **constraints, Expr **exprs,
2970 Expr *getOutputExpr(unsigned i);
2972 const Expr *getOutputExpr(unsigned i) const {
2998 Expr *getInputExpr(unsigned i);
2999 void setInputExpr(unsigned i, Expr *E);
3001 const Expr *getInputExpr(unsigned i) const {
3102 ArrayRef<Expr*> exprs, StringRef asmstr,
3131 Expr *getOutputExpr(unsigned i);
3133 const Expr *getOutputExpr(unsigned i) const {
3144 Expr *getInputExpr(unsigned i);
3145 void setInputExpr(unsigned i, Expr *E);
3147 const Expr *getInputExpr(unsigned i) const {
3161 ArrayRef<Expr*> getAllExprs() const {
3171 ArrayRef<Expr*> Exprs, ArrayRef<StringRef> Clobbers);
3198 SEHExceptStmt(SourceLocation Loc, Expr *FilterExpr, Stmt *Block);
3204 Expr *FilterExpr,
3212 Expr *getFilterExpr() const {
3433 ArrayRef<Expr *> CaptureInits, CapturedDecl *CD, RecordDecl *RD);
3454 ArrayRef<Expr *> CaptureInits,
3516 using capture_init_iterator = Expr **;
3521 using const_capture_init_iterator = Expr *const *;
tools/clang/include/clang/AST/StmtCXX.h 147 DeclStmt *End, Expr *Cond, Expr *Inc, DeclStmt *LoopVar,
147 DeclStmt *End, Expr *Cond, Expr *Inc, DeclStmt *LoopVar,
154 Expr *getRangeInit();
158 const Expr *getRangeInit() const;
166 Expr *getCond() { return cast_or_null<Expr>(SubExprs[COND]); }
166 Expr *getCond() { return cast_or_null<Expr>(SubExprs[COND]); }
167 Expr *getInc() { return cast_or_null<Expr>(SubExprs[INC]); }
167 Expr *getInc() { return cast_or_null<Expr>(SubExprs[INC]); }
180 const Expr *getCond() const {
181 return cast_or_null<Expr>(SubExprs[COND]);
183 const Expr *getInc() const {
184 return cast_or_null<Expr>(SubExprs[INC]);
192 void setRangeInit(Expr *E) { SubExprs[RANGE] = reinterpret_cast<Stmt*>(E); }
196 void setCond(Expr *E) { SubExprs[COND] = reinterpret_cast<Stmt*>(E); }
197 void setInc(Expr *E) { SubExprs[INC] = reinterpret_cast<Stmt*>(E); }
350 Expr *InitialSuspend = nullptr;
351 Expr *FinalSuspend = nullptr;
354 Expr *Allocate = nullptr;
355 Expr *Deallocate = nullptr;
356 Expr *ReturnValue = nullptr;
403 Expr *getAllocate() const {
404 return cast_or_null<Expr>(getStoredStmts()[SubStmt::Allocate]);
406 Expr *getDeallocate() const {
407 return cast_or_null<Expr>(getStoredStmts()[SubStmt::Deallocate]);
409 Expr *getReturnValueInit() const {
410 return cast<Expr>(getStoredStmts()[SubStmt::ReturnValue]);
480 Expr *getOperand() const { return static_cast<Expr*>(SubStmts[Operand]); }
485 Expr *getPromiseCall() const {
tools/clang/include/clang/AST/StmtObjC.h 29 ObjCForCollectionStmt(Stmt *Elem, Expr *Collect, Stmt *Body,
35 Expr *getCollection() {
41 const Expr *getCollection() const {
47 void setCollection(Expr *E) {
305 const Expr *getSynchExpr() const {
308 Expr *getSynchExpr() {
344 const Expr *getThrowExpr() const { return reinterpret_cast<Expr*>(Throw); }
345 Expr *getThrowExpr() { return reinterpret_cast<Expr*>(Throw); }
tools/clang/include/clang/AST/StmtOpenMP.h 486 MutableArrayRef<Expr *> getCounters() {
487 Expr **Storage = reinterpret_cast<Expr **>(
493 MutableArrayRef<Expr *> getPrivateCounters() {
494 Expr **Storage = reinterpret_cast<Expr **>(&*std::next(
500 MutableArrayRef<Expr *> getInits() {
501 Expr **Storage = reinterpret_cast<Expr **>(
508 MutableArrayRef<Expr *> getUpdates() {
509 Expr **Storage = reinterpret_cast<Expr **>(
516 MutableArrayRef<Expr *> getFinals() {
517 Expr **Storage = reinterpret_cast<Expr **>(
524 MutableArrayRef<Expr *> getDependentCounters() {
525 Expr **Storage = reinterpret_cast<Expr **>(
532 MutableArrayRef<Expr *> getDependentInits() {
533 Expr **Storage = reinterpret_cast<Expr **>(
540 MutableArrayRef<Expr *> getFinalsConditions() {
541 Expr **Storage = reinterpret_cast<Expr **>(
587 void setIterationVariable(Expr *IV) {
590 void setLastIteration(Expr *LI) {
593 void setCalcLastIteration(Expr *CLI) {
596 void setPreCond(Expr *PC) {
599 void setCond(Expr *Cond) {
602 void setInit(Expr *Init) { *std::next(child_begin(), InitOffset) = Init; }
603 void setInc(Expr *Inc) { *std::next(child_begin(), IncOffset) = Inc; }
607 void setIsLastIterVariable(Expr *IL) {
614 void setLowerBoundVariable(Expr *LB) {
621 void setUpperBoundVariable(Expr *UB) {
628 void setStrideVariable(Expr *ST) {
635 void setEnsureUpperBound(Expr *EUB) {
642 void setNextLowerBound(Expr *NLB) {
649 void setNextUpperBound(Expr *NUB) {
656 void setNumIterations(Expr *NI) {
663 void setPrevLowerBoundVariable(Expr *PrevLB) {
668 void setPrevUpperBoundVariable(Expr *PrevUB) {
673 void setDistInc(Expr *DistInc) {
678 void setPrevEnsureUpperBound(Expr *PrevEUB) {
683 void setCombinedLowerBoundVariable(Expr *CombLB) {
688 void setCombinedUpperBoundVariable(Expr *CombUB) {
693 void setCombinedEnsureUpperBound(Expr *CombEUB) {
698 void setCombinedInit(Expr *CombInit) {
703 void setCombinedCond(Expr *CombCond) {
708 void setCombinedNextLowerBound(Expr *CombNLB) {
713 void setCombinedNextUpperBound(Expr *CombNUB) {
718 void setCombinedDistCond(Expr *CombDistCond) {
723 void setCombinedParForInDistCond(Expr *CombParForInDistCond) {
729 void setCounters(ArrayRef<Expr *> A);
730 void setPrivateCounters(ArrayRef<Expr *> A);
731 void setInits(ArrayRef<Expr *> A);
732 void setUpdates(ArrayRef<Expr *> A);
733 void setFinals(ArrayRef<Expr *> A);
734 void setDependentCounters(ArrayRef<Expr *> A);
735 void setDependentInits(ArrayRef<Expr *> A);
736 void setFinalsConditions(ArrayRef<Expr *> A);
744 Expr *LB;
747 Expr *UB;
750 Expr *EUB;
754 Expr *Init;
757 Expr *Cond;
760 Expr *NLB;
763 Expr *NUB;
766 Expr *DistCond;
770 Expr *ParForInDistCond;
777 Expr *IterationVarRef;
779 Expr *LastIteration;
781 Expr *NumIterations;
783 Expr *CalcLastIteration;
785 Expr *PreCond;
787 Expr *Cond;
789 Expr *Init;
791 Expr *Inc;
793 Expr *IL;
795 Expr *LB;
797 Expr *UB;
799 Expr *ST;
801 Expr *EUB;
803 Expr *NLB;
805 Expr *NUB;
808 Expr *PrevLB;
811 Expr *PrevUB;
815 Expr *DistInc;
821 Expr *PrevEUB;
823 SmallVector<Expr *, 4> Counters;
825 SmallVector<Expr *, 4> PrivateCounters;
827 SmallVector<Expr *, 4> Inits;
829 SmallVector<Expr *, 4> Updates;
831 SmallVector<Expr *, 4> Finals;
834 SmallVector<Expr *, 4> DependentCounters;
837 SmallVector<Expr *, 4> DependentInits;
840 SmallVector<Expr *, 4> FinalsConditions;
913 Expr *getIterationVariable() const {
917 Expr *getLastIteration() const {
921 Expr *getCalcLastIteration() const {
925 Expr *getPreCond() const {
929 Expr *getCond() const {
933 Expr *getInit() const {
937 Expr *getInc() const {
945 Expr *getIsLastIterVariable() const {
953 Expr *getLowerBoundVariable() const {
961 Expr *getUpperBoundVariable() const {
969 Expr *getStrideVariable() const {
977 Expr *getEnsureUpperBound() const {
985 Expr *getNextLowerBound() const {
993 Expr *getNextUpperBound() const {
1001 Expr *getNumIterations() const {
1009 Expr *getPrevLowerBoundVariable() const {
1015 Expr *getPrevUpperBoundVariable() const {
1021 Expr *getDistInc() const {
1027 Expr *getPrevEnsureUpperBound() const {
1033 Expr *getCombinedLowerBoundVariable() const {
1039 Expr *getCombinedUpperBoundVariable() const {
1045 Expr *getCombinedEnsureUpperBound() const {
1051 Expr *getCombinedInit() const {
1057 Expr *getCombinedCond() const {
1063 Expr *getCombinedNextLowerBound() const {
1069 Expr *getCombinedNextUpperBound() const {
1075 Expr *getCombinedDistCond() const {
1081 Expr *getCombinedParForInDistCond() const {
1111 ArrayRef<Expr *> counters() { return getCounters(); }
1113 ArrayRef<Expr *> counters() const {
1117 ArrayRef<Expr *> private_counters() { return getPrivateCounters(); }
1119 ArrayRef<Expr *> private_counters() const {
1123 ArrayRef<Expr *> inits() { return getInits(); }
1125 ArrayRef<Expr *> inits() const {
1129 ArrayRef<Expr *> updates() { return getUpdates(); }
1131 ArrayRef<Expr *> updates() const {
1135 ArrayRef<Expr *> finals() { return getFinals(); }
1137 ArrayRef<Expr *> finals() const {
1141 ArrayRef<Expr *> dependent_counters() { return getDependentCounters(); }
1143 ArrayRef<Expr *> dependent_counters() const {
1147 ArrayRef<Expr *> dependent_inits() { return getDependentInits(); }
1149 ArrayRef<Expr *> dependent_inits() const {
1153 ArrayRef<Expr *> finals_conditions() { return getFinalsConditions(); }
1155 ArrayRef<Expr *> finals_conditions() const {
2154 void setReductionRef(Expr *RR) {
2171 Expr *ReductionRef);
2183 const Expr *getReductionRef() const {
2186 Expr *getReductionRef() {
2360 void setX(Expr *X) { *std::next(child_begin()) = X; }
2364 void setUpdateExpr(Expr *UE) { *std::next(child_begin(), 2) = UE; }
2366 void setV(Expr *V) { *std::next(child_begin(), 3) = V; }
2368 void setExpr(Expr *E) { *std::next(child_begin(), 4) = E; }
2392 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, Expr *X, Expr *V,
2392 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, Expr *X, Expr *V,
2393 Expr *E, Expr *UE, bool IsXLHSInRHSPart, bool IsPostfixUpdate);
2393 Expr *E, Expr *UE, bool IsXLHSInRHSPart, bool IsPostfixUpdate);
2405 Expr *getX() { return cast_or_null<Expr>(*std::next(child_begin())); }
2405 Expr *getX() { return cast_or_null<Expr>(*std::next(child_begin())); }
2406 const Expr *getX() const {
2407 return cast_or_null<Expr>(*std::next(child_begin()));
2412 Expr *getUpdateExpr() {
2413 return cast_or_null<Expr>(*std::next(child_begin(), 2));
2415 const Expr *getUpdateExpr() const {
2416 return cast_or_null<Expr>(*std::next(child_begin(), 2));
2426 Expr *getV() { return cast_or_null<Expr>(*std::next(child_begin(), 3)); }
2426 Expr *getV() { return cast_or_null<Expr>(*std::next(child_begin(), 3)); }
2427 const Expr *getV() const {
2428 return cast_or_null<Expr>(*std::next(child_begin(), 3));
2431 Expr *getExpr() { return cast_or_null<Expr>(*std::next(child_begin(), 4)); }
2431 Expr *getExpr() { return cast_or_null<Expr>(*std::next(child_begin(), 4)); }
2432 const Expr *getExpr() const {
2433 return cast_or_null<Expr>(*std::next(child_begin(), 4));
tools/clang/include/clang/AST/TemplateBase.h 209 TemplateArgument(Expr *E) {
329 Expr *getAsExpr() const {
405 Expr *Expression;
414 TemplateArgumentLocInfo(Expr *E) : Expression(E) {}
429 Expr *getAsExpr() const {
465 TemplateArgumentLoc(const TemplateArgument &Argument, Expr *E)
511 Expr *getSourceExpression() const {
516 Expr *getSourceDeclExpression() const {
521 Expr *getSourceNullPtrExpression() const {
526 Expr *getSourceIntegralExpression() const {
tools/clang/include/clang/AST/Type.h 2878 unsigned tq, const Expr *sz = nullptr);
2908 private llvm::TrailingObjects<ConstantArrayType, const Expr *> {
2915 const Expr *sz, ArraySizeModifier sm, unsigned tq)
2920 *getTrailingObjects<const Expr*>() = sz;
2924 unsigned numTrailingObjects(OverloadToken<const Expr*>) const {
2930 const Expr *getSizeExpr() const {
2932 ? *getTrailingObjects<const Expr *>()
2955 const Expr *SizeExpr, ArraySizeModifier SizeMod,
3020 VariableArrayType(QualType et, QualType can, Expr *e,
3029 Expr *getSizeExpr() const {
3080 Expr *e, ArraySizeModifier sm, unsigned tq,
3086 Expr *getSizeExpr() const {
3110 unsigned TypeQuals, Expr *E);
3128 Expr *AddrSpaceExpr;
3133 QualType can, Expr *AddrSpaceExpr,
3137 Expr *getAddrSpaceExpr() const { return AddrSpaceExpr; }
3153 QualType PointeeType, Expr *AddrSpaceExpr);
3170 Expr *SizeExpr;
3178 QualType can, Expr *SizeExpr, SourceLocation loc);
3181 Expr *getSizeExpr() const { return SizeExpr; }
3197 QualType ElementType, Expr *SizeExpr);
3288 Expr *SizeExpr;
3292 QualType CanonType, Expr *SizeExpr,
3296 Expr *getSizeExpr() const { return SizeExpr; }
3315 QualType ElementType, const Expr *SizeExpr,
3730 FunctionType::ExceptionType, Expr *, FunctionDecl *,
3787 Expr *NoexceptExpr = nullptr;
3839 unsigned numTrailingObjects(OverloadToken<Expr *>) const {
4002 Expr *getNoexceptExpr() const {
4005 return *getTrailingObjects<Expr *>();
4251 Expr *TOExpr;
4256 TypeOfExprType(Expr *E, QualType can = QualType());
4259 Expr *getUnderlyingExpr() const { return TOExpr; }
4281 DependentTypeOfExprType(const ASTContext &Context, Expr *E)
4289 Expr *E);
4321 Expr *E;
4327 DecltypeType(Expr *E, QualType underlyingType, QualType can = QualType());
4330 Expr *getUnderlyingExpr() const { return E; }
4352 DependentDecltypeType(const ASTContext &Context, Expr *E);
4359 Expr *E);
tools/clang/include/clang/AST/TypeLoc.h 1491 Expr *Size;
1520 Expr *getSizeExpr() const {
1524 void setSizeExpr(Expr *Size) {
1687 Expr *ExprOperand;
1711 Expr *getAttrExprOperand() const {
1714 void setAttrExprOperand(Expr *e) {
1859 Expr* getUnderlyingExpr() const {
1892 Expr *getUnderlyingExpr() const { return getTypePtr()->getUnderlyingExpr(); }
tools/clang/include/clang/ASTMatchers/ASTMatchFinder.h 266 const NodeT *
269 if (const NodeT *Node = N.getNodeAs<NodeT>(BoundTo))
269 if (const NodeT *Node = N.getNodeAs<NodeT>(BoundTo))
tools/clang/include/clang/ASTMatchers/ASTMatchers.h 110 const T *getNodeAs(StringRef ID) const {
111 return MyBoundNodes.getNodeAs<T>(ID);
625 const Expr *Initializer = Node.getInClassInitializer();
824 const Expr *E = Node.IgnoreParens();
1493 const Expr *SyntForm = Node.getSyntacticForm();
1789 extern const internal::VariadicDynCastAllOfMatcher<Stmt, Expr> expr;
1903 const Expr *const Init = Node.getRangeInit();
3016 const Expr *ExprNode = Node.getImplicitObjectArgument()
3117 const Expr *ReceiverNode = Node.getInstanceReceiver();
3235 const Expr *ExprNode = Node.getCallee();
3439 const Expr *ExprNode = Node.getImplicitObjectArgument();
3562 const Expr *Initializer = Node.getAnyInitializer();
3839 const Expr* NodeAsExpr = Node.getInit();
3925 for (const Expr *Arg : Node.arguments()) {
4287 const Expr *const Condition = Node.getCond();
4380 if (const Expr* Expression = Node.getIdx())
4397 if (const Expr* Expression = Node.getBase())
4563 const Expr *LeftHandSide = Node.getLHS();
4578 const Expr *RightHandSide = Node.getRHS();
4586 const internal::Matcher<Expr> &InnerMatcher) {
4599 const Expr * const Operand = Node.getSubExpr();
4623 const Expr *const SubExpression =
4711 const Expr *Expression = Node.getTrueExpr();
4726 const Expr *Expression = Node.getFalseExpr();
6419 if (const auto *RetValue = Node.getRetValue())
6450 Expr::NPC_ValueDependentIsNull);
6612 const Expr *E = &Node;
tools/clang/include/clang/ASTMatchers/ASTMatchersInternal.h 120 inline QualType getUnderlyingType(const Expr &Node) { return Node.getType(); }
160 const T *getNodeAs(StringRef ID) const {
165 return It->second.get<T>();
302 virtual bool matches(const T &Node,
309 return matches(DynNode.getUnchecked<T>(), Finder, Builder);
345 DynTypedMatcher(MatcherInterface<T> *Implementation)
346 : SupportedKind(ast_type_traits::ASTNodeKind::getFromNodeKind<T>()),
436 return canConvertTo(ast_type_traits::ASTNodeKind::getFromNodeKind<T>());
445 template <typename T> Matcher<T> convertTo() const {
447 return unconditionalConvertTo<T>();
479 class WrapperMatcherInterface : public MatcherInterface<T> {
499 explicit Matcher(MatcherInterface<T> *Implementation)
506 Matcher(const Matcher<From> &Other,
507 typename std::enable_if<std::is_base_of<From, T>::value &&
507 typename std::enable_if<std::is_base_of<From, T>::value &&
508 !std::is_same<From, T>::value>::type * = nullptr)
508 !std::is_same<From, T>::value>::type * = nullptr)
520 std::is_same<T, QualType>::value &&
528 Matcher<To> dynCastTo() const {
529 static_assert(std::is_base_of<To, T>::value, "Invalid dynCast call.");
529 static_assert(std::is_base_of<To, T>::value, "Invalid dynCast call.");
534 bool matches(const T &Node,
581 return Other.dynCastTo(ast_type_traits::ASTNodeKind::getFromNodeKind<T>());
596 inline Matcher<T> makeMatcher(MatcherInterface<T> *Implementation) {
596 inline Matcher<T> makeMatcher(MatcherInterface<T> *Implementation) {
994 bool matchesChildOf(const T &Node, const DynTypedMatcher &Matcher,
997 static_assert(std::is_base_of<Decl, T>::value ||
998 std::is_base_of<Stmt, T>::value ||
999 std::is_base_of<NestedNameSpecifier, T>::value ||
1000 std::is_base_of<NestedNameSpecifierLoc, T>::value ||
1001 std::is_base_of<TypeLoc, T>::value ||
1002 std::is_base_of<QualType, T>::value,
1009 bool matchesDescendantOf(const T &Node,
1013 static_assert(std::is_base_of<Decl, T>::value ||
1014 std::is_base_of<Stmt, T>::value ||
1015 std::is_base_of<NestedNameSpecifier, T>::value ||
1016 std::is_base_of<NestedNameSpecifierLoc, T>::value ||
1017 std::is_base_of<TypeLoc, T>::value ||
1018 std::is_base_of<QualType, T>::value,
1026 bool matchesAncestorOf(const T &Node,
1030 static_assert(std::is_base_of<Decl, T>::value ||
1031 std::is_base_of<NestedNameSpecifierLoc, T>::value ||
1032 std::is_base_of<Stmt, T>::value ||
1033 std::is_base_of<TypeLoc, T>::value,
1067 using head = T1;
1084 std::is_base_of<typename AnyTypeList::head, T>::value ||
1085 TypeListContainsSuperOf<typename AnyTypeList::tail, T>::value;
1141 explicit Adaptor(const Matcher<T> &InnerMatcher)
1146 template <typename To> operator Matcher<To>() const {
1151 const Matcher<T> InnerMatcher;
1155 static Adaptor<T> create(const Matcher<T> &InnerMatcher) {
1155 static Adaptor<T> create(const Matcher<T> &InnerMatcher) {
1160 Adaptor<T> operator()(const Matcher<T> &InnerMatcher) const {
1160 Adaptor<T> operator()(const Matcher<T> &InnerMatcher) const {
1202 operator Matcher<T>() const {
1203 static_assert(TypeListContainsSuperOf<ReturnTypes, T>::value,
1243 operator Matcher<T>() const {
1245 ast_type_traits::ASTNodeKind::getFromNodeKind<T>())
1246 .template unconditionalConvertTo<T>();
1255 class BindableMatcher : public Matcher<T> {
1257 explicit BindableMatcher(const Matcher<T> &M) : Matcher<T>(M) {}
1258 explicit BindableMatcher(MatcherInterface<T> *Implementation)
1265 Matcher<T> bind(StringRef ID) const {
1285 class HasMatcher : public WrapperMatcherInterface<T> {
1287 explicit HasMatcher(const Matcher<ChildT> &ChildMatcher)
1290 bool matches(const T &Node, ASTMatchFinder *Finder,
1335 template <typename T> operator Matcher<T>() const {
1337 Op, ast_type_traits::ASTNodeKind::getFromNodeKind<T>(),
1338 getMatchers<T>(std::index_sequence_for<Ps...>()))
1339 .template unconditionalConvertTo<T>();
1370 inline Matcher<T> DynTypedMatcher::unconditionalConvertTo() const {
1376 BindableMatcher<T> makeAllOfComposite(
1377 ArrayRef<const Matcher<T> *> InnerMatchers) {
1388 using PI = llvm::pointee_iterator<const Matcher<T> *const *>;
1395 ast_type_traits::ASTNodeKind::getFromNodeKind<T>(),
1397 .template unconditionalConvertTo<T>());
1407 BindableMatcher<T> makeDynCastAllOfComposite(
1408 ArrayRef<const Matcher<InnerT> *> InnerMatchers) {
1410 makeAllOfComposite(InnerMatchers).template dynCastTo<T>());
1418 class HasDescendantMatcher : public WrapperMatcherInterface<T> {
1426 bool matches(const T &Node, ASTMatchFinder *Finder,
1438 class HasParentMatcher : public WrapperMatcherInterface<T> {
1446 bool matches(const T &Node, ASTMatchFinder *Finder,
1458 class HasAncestorMatcher : public WrapperMatcherInterface<T> {
1466 bool matches(const T &Node, ASTMatchFinder *Finder,
1480 class ForEachDescendantMatcher : public WrapperMatcherInterface<T> {
1489 bool matches(const T &Node, ASTMatchFinder *Finder,
1557 : public VariadicFunction<BindableMatcher<SourceT>, Matcher<TargetT>,
1557 : public VariadicFunction<BindableMatcher<SourceT>, Matcher<TargetT>,
1558 makeDynCastAllOfComposite<SourceT, TargetT>> {
1558 makeDynCastAllOfComposite<SourceT, TargetT>> {
1792 static const Expr *get(const Ty &Node) {
1798 inline const Expr *GetSourceExpressionMatcher<OpaqueValueExpr>::get(
tools/clang/include/clang/ASTMatchers/Dynamic/VariantValue.h 199 ast_matchers::internal::Matcher<T> getTypedMatcher() const {
202 ->template convertTo<T>();
227 : MatcherOps(ast_type_traits::ASTNodeKind::getFromNodeKind<T>()) {}
228 typedef ast_matchers::internal::Matcher<T> MatcherT;
232 return DynTypedMatcher(Matcher.convertTo<T>());
tools/clang/include/clang/Analysis/Analyses/ExprMutationAnalyzer.h 28 bool isMutated(const Expr *Exp) { return findMutation(Exp) != nullptr; }
30 const Stmt *findMutation(const Expr *Exp);
33 bool isPointeeMutated(const Expr *Exp) {
39 const Stmt *findPointeeMutation(const Expr *Exp);
44 using ResultMap = llvm::DenseMap<const Expr *, const Stmt *>;
46 const Stmt *findMutationMemoized(const Expr *Exp,
51 bool isUnevaluated(const Expr *Exp);
60 const Stmt *findDirectMutation(const Expr *Exp);
61 const Stmt *findMemberMutation(const Expr *Exp);
62 const Stmt *findArrayElementMutation(const Expr *Exp);
63 const Stmt *findCastMutation(const Expr *Exp);
64 const Stmt *findRangeLoopMutation(const Expr *Exp);
65 const Stmt *findReferenceMutation(const Expr *Exp);
66 const Stmt *findFunctionArgMutation(const Expr *Exp);
tools/clang/include/clang/Analysis/Analyses/ThreadSafetyCommon.h 348 const Expr *SelfArg = nullptr;
354 const Expr *const *FunArgs = nullptr;
371 CapabilityExpr translateAttrExpr(const Expr *AttrExp, const NamedDecl *D,
372 const Expr *DeclExp, VarDecl *SelfD=nullptr);
374 CapabilityExpr translateAttrExpr(const Expr *AttrExp, CallingContext *Ctx);
402 const Expr *SelfE = nullptr);
tools/clang/include/clang/Analysis/Analyses/ThreadSafetyTIL.h 531 Literal(const Expr *C)
539 const Expr *clangExpr() const { return Cexpr; }
560 const Expr *Cexpr = nullptr;
tools/clang/include/clang/Analysis/Analyses/ThreadSafetyUtil.h 78 std::string getSourceLiteralString(const Expr *CE);
tools/clang/include/clang/Analysis/Analyses/UninitializedValues.h 39 const Expr *User;
55 UninitUse(const Expr *User, bool AlwaysUninit)
66 const Expr *getUser() const { return User; }
tools/clang/include/clang/Analysis/AnyCall.h 58 const Expr *E = nullptr;
106 static Optional<AnyCall> forExpr(const Expr *E) {
191 const Expr *getExpr() const {
tools/clang/include/clang/Analysis/CFG.h 188 static bool isCXXRecordTypedCall(Expr *E) {
197 explicit CFGCXXRecordTypedCall(Expr *E, const ConstructionContext *C)
1060 const Expr *getLastCondition() const;
1105 void appendCXXRecordTypedCall(Expr *E,
tools/clang/include/clang/Analysis/ConstructionContext.h 117 ConstructionContextItem(const Expr *E, unsigned Index)
627 const Expr *CE;
639 explicit ArgumentConstructionContext(const Expr *CE, unsigned Index,
649 const Expr *getCallLikeExpr() const { return CE; }
tools/clang/include/clang/Index/IndexDataConsumer.h 29 const Expr *OrigE;
tools/clang/include/clang/Parse/LoopHint.h 35 Expr *ValueExpr;
tools/clang/include/clang/Parse/Parser.h 300 Expr *TemplateName;
323 void add(Parser &P, Expr *TemplateName, SourceLocation LessLoc,
1705 typedef SmallVector<Expr*, 20> ExprListTy;
1709 bool ParseExpressionList(SmallVectorImpl<Expr *> &Exprs,
1716 bool ParseSimpleExpressionList(SmallVectorImpl<Expr*> &Exprs,
1811 ExprResult ParseCXXPseudoDestructor(Expr *Base, SourceLocation OpLoc,
1860 bool ParseExpressionListOrTypeId(SmallVectorImpl<Expr*> &Exprs,
1919 Expr *ReceiverExpr);
1922 ParsedType ReceiverType, Expr *ReceiverExpr);
1932 typedef SmallVector<Expr*, 12> ExprVector;
2021 SmallVectorImpl<Expr *> &Constraints,
2022 SmallVectorImpl<Expr *> &Exprs);
2961 Expr *TailExpr = nullptr;
2979 SmallVectorImpl<Expr *> &Vars,
tools/clang/include/clang/Sema/DeclSpec.h 371 Expr *ExprRep;
490 Expr *getRepAsExpr() const {
671 unsigned &DiagID, Expr *Rep,
696 void UpdateExprRep(Expr *Rep) {
1222 Expr *NumElts;
1339 Expr *NoexceptExpr;
1586 bool isStatic, bool isStar, Expr *NumElts,
1615 Expr *NoexceptExpr,
1826 Expr *AsmLabel;
2440 void setAsmLabel(Expr *E) { AsmLabel = E; }
2441 Expr *getAsmLabel() const { return AsmLabel; }
2502 Expr *BitfieldSize;
tools/clang/include/clang/Sema/Designator.h 50 Expr *Index;
55 Expr *Start, *End;
88 Expr *getArrayIndex() const {
93 Expr *getArrayRangeStart() const {
97 Expr *getArrayRangeEnd() const {
135 static Designator getArray(Expr *Index,
145 static Designator getArrayRange(Expr *Start,
146 Expr *End,
tools/clang/include/clang/Sema/Initialization.h 673 Expr *Init) {
1167 ArrayRef<Expr *> Args);
1208 bool endsWithNarrowing(ASTContext &Ctx, const Expr *Initializer,
tools/clang/include/clang/Sema/Overload.h 360 getNarrowingKind(ASTContext &Context, const Expr *Converted,
473 Expr *FromExpr;
485 void init(FailureKind K, Expr *From, QualType To) {
500 void setFromExpr(Expr *E) {
641 Expr *FromExpr, QualType ToType) {
1070 Sema &S, OverloadCandidateDisplayKind OCD, ArrayRef<Expr *> Args,
1077 ArrayRef<Expr *> Args, StringRef Opc = "",
1082 void NoteCandidates(Sema &S, ArrayRef<Expr *> Args,
tools/clang/include/clang/Sema/Ownership.h 217 template <typename T> T *getAs() { return static_cast<T*>(get()); }
263 using ExprResult = ActionResult<Expr *>;
273 using MultiExprArg = MutableArrayRef<Expr *>;
288 inline Expr *AssertSuccess(ExprResult R) {
tools/clang/include/clang/Sema/ParsedAttr.h 67 const Expr *Replacement;
72 SourceLocation Strict, const Expr *ReplaceExpr)
105 using ArgsUnion = llvm::PointerUnion<Expr *, IdentifierLoc *>;
182 const Expr *MessageExpr;
221 const Expr *messageExpr, Syntax syntaxUsed, SourceLocation strict,
222 const Expr *replacementExpr)
380 return Arg < NumArgs && getArg(Arg).is<Expr*>();
383 Expr *getArgAsExpr(unsigned Arg) const {
384 return getArg(Arg).get<Expr*>();
425 const Expr * getMessageExpr() const {
431 const Expr *getReplacementExpr() const {
671 SourceLocation unavailable, const Expr *MessageExpr,
673 const Expr *ReplacementExpr) {
867 SourceLocation unavailable, const Expr *MessageExpr,
869 const Expr *ReplacementExpr) {
tools/clang/include/clang/Sema/ParsedTemplate.h 82 Expr *getAsExpr() const {
tools/clang/include/clang/Sema/ScopeInfo.h 268 WeakObjectProfileTy(const Expr *Base, const ObjCPropertyDecl *Property);
329 llvm::PointerIntPair<const Expr *, 1, bool> Rep;
332 WeakUseTy(const Expr *Use, bool IsRead) : Rep(Use, IsRead) {}
334 const Expr *getUseExpr() const { return Rep.getPointer(); }
390 void markSafeWeakUse(const Expr *E);
863 llvm::SmallVector<Expr*, 4> PotentiallyCapturingExprs;
869 llvm::SmallSet<Expr *, 8> NonODRUsedCapturingExprs;
922 void addPotentialCapture(Expr *VarExpr) {
975 void markVariableExprAsNonODRUsed(Expr *CapturingVarExpr) {
981 bool isVariableExprMarkedAsNonODRUsed(Expr *CapturingVarExpr) const {
987 void removePotentialCapture(Expr *E) {
1007 llvm::function_ref<void(VarDecl *, Expr *)> Callback) const;
tools/clang/include/clang/Sema/Sema.h 304 void enterBinary(Sema &S, SourceLocation Tok, Expr *LHS, tok::TokenKind Op);
305 void enterMemAccess(Sema &S, SourceLocation Tok, Expr *Base);
306 void enterSubscript(Sema &S, SourceLocation Tok, Expr *LHS);
606 using MaybeODRUseExprSet = llvm::SmallPtrSet<Expr *, 2>;
1061 llvm::SmallPtrSet<const Expr *, 8> PossibleDerefs;
1066 SmallVector<Expr*, 2> VolatileAssignmentLHSs;
1272 bool isSelfExpr(Expr *RExpr);
1273 bool isSelfExpr(Expr *RExpr, const ObjCMethodDecl *Method);
1526 Expr *ArraySize, unsigned Quals,
1528 QualType BuildVectorType(QualType T, Expr *VecSize, SourceLocation AttrLoc);
1529 QualType BuildExtVectorType(QualType T, Expr *ArraySize,
1531 QualType BuildAddressSpaceAttr(QualType &T, LangAS ASIdx, Expr *AddrSpace,
1535 QualType BuildAddressSpaceAttr(QualType &T, Expr *AddrSpace,
1595 CanThrowResult canThrow(const Expr *E);
1653 static SourceRange getPrintable(const Expr *E) { return E->getSourceRange(); }
1690 void CheckAddressOfNoDeref(const Expr *E);
1798 void completeExprArrayBound(Expr *E);
1799 bool RequireCompleteExprType(Expr *E, TypeDiagnoser &Diagnoser);
1800 bool RequireCompleteExprType(Expr *E, unsigned DiagID);
1803 bool RequireCompleteExprType(Expr *E, unsigned DiagID, const Ts &...Args) {
1823 QualType BuildTypeofExprType(Expr *E, SourceLocation Loc);
1826 QualType BuildDecltypeType(Expr *E, SourceLocation Loc,
2128 void CheckShadowingDeclModification(Expr *E, SourceLocation Loc);
2138 void CheckCastAlign(Expr *Op, QualType T, SourceRange TRange);
2161 Expr *Init);
2211 Expr *defarg);
2216 bool SetParamDefaultArgument(ParmVarDecl *Param, Expr *DefaultArg,
2246 void checkNonTrivialCUnionInInitializer(const Expr *Init, SourceLocation Loc);
2261 void AddInitializerToDecl(Decl *dcl, Expr *init, bool DirectInit);
2340 Decl *ActOnFileScopeAsmDecl(Expr *expr,
2526 Declarator &D, Expr *BitfieldWidth);
2529 Declarator &D, Expr *BitfieldWidth,
2534 Expr *BitfieldWidth,
2542 bool Mutable, Expr *BitfieldWidth,
2611 Declarator &D, Expr *BitfieldWidth,
2669 Expr *val);
2683 SourceLocation EqualLoc, Expr *Val);
2880 TryImplicitConversion(Expr *From, QualType ToType,
2887 bool IsIntegralPromotion(Expr *From, QualType FromType, QualType ToType);
2890 bool IsPointerConversion(Expr *From, QualType FromType, QualType ToType,
2907 bool CheckPointerConversion(Expr *From, QualType ToType,
2912 bool IsMemberPointerConversion(Expr *From, QualType FromType, QualType ToType,
2915 bool CheckMemberPointerConversion(Expr *From, QualType ToType,
2923 bool DiagnoseMultipleUserDefinedConversion(Expr *From, QualType ToType);
2929 Expr *Value,
2942 ExprResult PerformObjectArgumentInitialization(Expr *From,
2950 void checkInitializerLifetime(const InitializedEntity &Entity, Expr *Init);
2952 ExprResult PerformContextuallyConvertToBool(Expr *From);
2953 ExprResult PerformContextuallyConvertToObjCPointer(Expr *From);
2964 ExprResult CheckConvertedConstantExpression(Expr *From, QualType T,
2966 ExprResult CheckConvertedConstantExpression(Expr *From, QualType T,
3044 SourceLocation Loc, Expr *FromE, ContextualImplicitConverter &Converter);
3052 ObjCSubscriptKind CheckSubscriptingKind(Expr *FromE);
3065 ObjCLiteralKind CheckLiteralKind(Expr *FromE);
3067 ExprResult PerformObjectMemberConversion(Expr *From,
3080 ArrayRef<Expr *> Args,
3090 ArrayRef<Expr *> Args,
3098 Expr::Classification ObjectClassification,
3099 ArrayRef<Expr *> Args,
3106 Expr::Classification ObjectClassification,
3107 ArrayRef<Expr *> Args,
3118 Expr::Classification ObjectClassification,
3119 ArrayRef<Expr *> Args,
3126 TemplateArgumentListInfo *ExplicitTemplateArgs, ArrayRef<Expr *> Args,
3133 ArrayRef<Expr *> Args, OverloadCandidateSet &CandidateSet,
3136 Expr::Classification ObjectClassification = {},
3140 CXXRecordDecl *ActingContext, Expr *From, QualType ToType,
3145 CXXRecordDecl *ActingContext, Expr *From, QualType ToType,
3152 Expr *Object, ArrayRef<Expr *> Args,
3152 Expr *Object, ArrayRef<Expr *> Args,
3155 const UnresolvedSetImpl &Functions, ArrayRef<Expr *> Args,
3159 SourceLocation OpLoc, ArrayRef<Expr *> Args,
3162 void AddBuiltinCandidate(QualType *ParamTys, ArrayRef<Expr *> Args,
3167 SourceLocation OpLoc, ArrayRef<Expr *> Args,
3171 ArrayRef<Expr *> Args,
3184 void NoteAllOverloadCandidates(Expr *E, QualType DestType = QualType(),
3189 EnableIfAttr *CheckEnableIf(FunctionDecl *Function, ArrayRef<Expr *> Args,
3194 std::pair<Expr *, std::string> findFailedBooleanCondition(Expr *Cond);
3194 std::pair<Expr *, std::string> findFailedBooleanCondition(Expr *Cond);
3204 const Expr *ThisArg,
3205 ArrayRef<const Expr *> Args,
3235 ResolveAddressOfOverloadedFunction(Expr *AddressOfExpr,
3242 resolveAddressOfOnlyViableOverloadCandidate(Expr *E,
3262 Expr *FixOverloadedFunctionReference(Expr *E,
3262 Expr *FixOverloadedFunctionReference(Expr *E,
3270 ArrayRef<Expr *> Args,
3287 Expr *Range, ExprResult *CallExpr);
3289 ExprResult BuildOverloadedCallExpr(Scope *S, Expr *Fn,
3294 Expr *ExecConfig,
3298 bool buildOverloadedCallSet(Scope *S, Expr *Fn, UnresolvedLookupExpr *ULE,
3306 Expr *input, bool RequiresADL = true);
3311 Expr *LHS, Expr *RHS,
3311 Expr *LHS, Expr *RHS,
3317 Expr *Base,Expr *Idx);
3317 Expr *Base,Expr *Idx);
3320 BuildCallToMemberFunction(Scope *S, Expr *MemExpr,
3325 BuildCallToObjectOfClassType(Scope *S, Expr *Object, SourceLocation LParenLoc,
3329 ExprResult BuildOverloadedArrowExpr(Scope *S, Expr *Base,
3598 ArrayRef<Expr *> Args, ADLResult &Functions);
3650 CorrectDelayedTyposInExpr(Expr *E, VarDecl *InitDecl = nullptr,
3651 llvm::function_ref<ExprResult(Expr *)> Filter =
3652 [](Expr *E) -> ExprResult { return E; });
3655 CorrectDelayedTyposInExpr(Expr *E,
3656 llvm::function_ref<ExprResult(Expr *)> Filter) {
3662 llvm::function_ref<ExprResult(Expr *)> Filter =
3663 [](Expr *E) -> ExprResult { return E; }) {
3669 llvm::function_ref<ExprResult(Expr *)> Filter) {
3685 ArrayRef<Expr *> Args,
4012 Expr *get() const { return E; }
4014 Expr *operator->() {
4023 explicit FullExprArg(Expr *expr) : E(expr) {}
4025 Expr *E;
4028 FullExprArg MakeFullExpr(Expr *Arg) {
4031 FullExprArg MakeFullExpr(Expr *Arg, SourceLocation CC) {
4035 FullExprArg MakeFullDiscardedValueExpr(Expr *Arg) {
4084 StmtResult ActOnForEachLValueExpr(Expr *E);
4119 Expr *Cond, SourceLocation CondRParen);
4129 Expr *collection);
4131 Stmt *First, Expr *collection,
4150 SourceLocation ColonLoc, Expr *Collection,
4158 Expr *Cond, Expr *Inc,
4158 Expr *Cond, Expr *Inc,
4169 Expr *DestExp);
4197 VarDecl *getCopyElisionCandidate(QualType ReturnType, Expr *E,
4202 StmtResult ActOnReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp,
4204 StmtResult BuildReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp);
4205 StmtResult ActOnCapScopeReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp);
4211 Expr *AsmString, MultiExprArg Clobbers,
4215 void FillInlineAsmIdentifierInfo(Expr *Res,
4223 ExprResult LookupInlineAsmVarDeclField(Expr *RefExpr, StringRef Member,
4231 ArrayRef<Expr*> Exprs,
4252 StmtResult BuildObjCAtThrowStmt(SourceLocation AtLoc, Expr *Throw);
4253 StmtResult ActOnObjCAtThrowStmt(SourceLocation AtLoc, Expr *Throw,
4256 Expr *operand);
4258 Expr *SynchExpr,
4279 Expr *FilterExpr,
4316 void DiagnoseSelfMove(const Expr *LHSExpr, const Expr *RHSExpr,
4316 void DiagnoseSelfMove(const Expr *LHSExpr, const Expr *RHSExpr,
4325 void diagnoseZeroToNullptrConversion(CastKind Kind, const Expr *E);
4369 ArrayRef<Expr *> Args);
4384 ExprResult TransformToPotentiallyEvaluated(Expr *E);
4385 ExprResult HandleExprEvaluationContextForTypeof(Expr *E);
4387 ExprResult CheckUnevaluatedOperand(Expr *E);
4388 void CheckUnusedVolatileAssignment(Expr *E);
4408 void MarkDeclRefReferenced(DeclRefExpr *E, const Expr *Base = nullptr);
4414 ExprResult CheckLValueToRValueConversionOperand(Expr *E);
4476 void MarkDeclarationsReferencedInExpr(Expr *E,
4487 bool tryExprAsCall(Expr &E, QualType &ZeroArgCallReturnTy,
4505 SourceRange getExprRange(Expr *E) const;
4522 ArrayRef<Expr *> Args = None, TypoExpr **Out = nullptr);
4566 Expr *baseObjectExpr = nullptr,
4607 ArrayRef<Expr *> Args,
4616 bool CheckLoopHintExpr(Expr *E, SourceLocation Loc);
4621 ExprResult ActOnParenExpr(SourceLocation L, SourceLocation R, Expr *E);
4634 Expr *ControllingExpr,
4636 ArrayRef<Expr *> ArgExprs);
4640 Expr *ControllingExpr,
4642 ArrayRef<Expr *> Exprs);
4646 Expr *InputExpr);
4648 UnaryOperatorKind Opc, Expr *Input);
4650 tok::TokenKind Op, Expr *Input);
4652 bool isQualifiedMemberAccess(Expr *E);
4659 ExprResult CreateUnaryExprOrTypeTraitExpr(Expr *E, SourceLocation OpLoc,
4667 ExprResult CheckPlaceholderExpr(Expr *E);
4668 bool CheckVecStepExpr(Expr *E);
4670 bool CheckUnaryExprOrTypeTraitOperand(Expr *E, UnaryExprOrTypeTrait ExprKind);
4680 tok::TokenKind Kind, Expr *Input);
4682 ExprResult ActOnArraySubscriptExpr(Scope *S, Expr *Base, SourceLocation LLoc,
4683 Expr *Idx, SourceLocation RLoc);
4684 ExprResult CreateBuiltinArraySubscriptExpr(Expr *Base, SourceLocation LLoc,
4685 Expr *Idx, SourceLocation RLoc);
4686 ExprResult ActOnOMPArraySectionExpr(Expr *Base, SourceLocation LBLoc,
4687 Expr *LowerBound, SourceLocation ColonLoc,
4688 Expr *Length, SourceLocation RBLoc);
4702 Expr *Base, QualType BaseType, SourceLocation OpLoc, bool IsArrow,
4710 BuildMemberReferenceExpr(Expr *Base, QualType BaseType, SourceLocation OpLoc,
4719 ExprResult BuildFieldReferenceExpr(Expr *BaseExpr, bool IsArrow,
4725 ExprResult PerformMemberExprBaseConversion(Expr *Base, bool IsArrow);
4727 bool CheckQualifiedMemberReference(Expr *BaseExpr, QualType BaseType,
4731 ExprResult ActOnDependentMemberExpr(Expr *Base, QualType BaseType,
4739 ExprResult ActOnMemberAccessExpr(Scope *S, Expr *Base,
4748 BuildMemberExpr(Expr *Base, bool IsArrow, SourceLocation OpLoc,
4756 BuildMemberExpr(Expr *Base, bool IsArrow, SourceLocation OpLoc,
4765 bool ConvertArgumentsForCall(CallExpr *Call, Expr *Fn,
4768 ArrayRef<Expr *> Args,
4773 const Expr *ArgExpr);
4778 ExprResult ActOnCallExpr(Scope *S, Expr *Fn, SourceLocation LParenLoc,
4780 Expr *ExecConfig = nullptr);
4781 ExprResult BuildCallExpr(Scope *S, Expr *Fn, SourceLocation LParenLoc,
4783 Expr *ExecConfig = nullptr,
4792 BuildResolvedCallExpr(Expr *Fn, NamedDecl *NDecl, SourceLocation LParenLoc,
4793 ArrayRef<Expr *> Arg, SourceLocation RParenLoc,
4794 Expr *Config = nullptr, bool IsExecConfig = false,
4803 SourceLocation RParenLoc, Expr *CastExpr);
4807 Expr *Op);
4812 SourceLocation RParenLoc, Expr *E,
4815 ExprResult MaybeConvertParenListExprToParenExpr(Scope *S, Expr *ME);
4820 Expr *InitExpr);
4825 Expr *LiteralExpr);
4845 tok::TokenKind Kind, Expr *LHSExpr, Expr *RHSExpr);
4845 tok::TokenKind Kind, Expr *LHSExpr, Expr *RHSExpr);
4847 BinaryOperatorKind Opc, Expr *LHSExpr, Expr *RHSExpr);
4847 BinaryOperatorKind Opc, Expr *LHSExpr, Expr *RHSExpr);
4849 Expr *LHSExpr, Expr *RHSExpr);
4849 Expr *LHSExpr, Expr *RHSExpr);
4851 void DiagnoseCommaOperator(const Expr *LHS, SourceLocation Loc);
4857 Expr *CondExpr, Expr *LHSExpr, Expr *RHSExpr);
4857 Expr *CondExpr, Expr *LHSExpr, Expr *RHSExpr);
4857 Expr *CondExpr, Expr *LHSExpr, Expr *RHSExpr);
4876 Expr *E;
4894 Expr *CondExpr, Expr *LHSExpr,
4894 Expr *CondExpr, Expr *LHSExpr,
4895 Expr *RHSExpr, SourceLocation RPLoc);
4898 ExprResult ActOnVAArg(SourceLocation BuiltinLoc, Expr *E, ParsedType Ty,
4900 ExprResult BuildVAArgExpr(SourceLocation BuiltinLoc, Expr *E,
4917 bool CheckCaseExpression(Expr *E);
4977 ExprResult ActOnConvertVectorExpr(Expr *E, ParsedType ParsedDestTy,
4984 ExprResult ActOnAsTypeExpr(Expr *E, ParsedType ParsedDestTy,
5202 void CalledExpr(Expr *E);
5268 ExprResult ActOnNoexceptSpec(SourceLocation NoexceptLoc, Expr *NoexceptExpr,
5277 Expr *NoexceptExpr,
5293 Expr *NoexceptExpr);
5422 ExprResult MaybeBindToTemporary(Expr *E);
5427 SmallVectorImpl<Expr*> &ConvertedArgs,
5458 Expr *E,
5464 Expr *E,
5473 Expr *Operand, SourceLocation RParenLoc);
5481 Expr *Operand,
5496 Expr *Operand,
5506 ExprResult ActOnCXXFoldExpr(SourceLocation LParenLoc, Expr *LHS,
5508 SourceLocation EllipsisLoc, Expr *RHS,
5510 ExprResult BuildCXXFoldExpr(SourceLocation LParenLoc, Expr *LHS,
5512 SourceLocation EllipsisLoc, Expr *RHS,
5522 Expr *BuildCXXThisExpr(SourceLocation Loc, QualType Type, bool IsImplicit);
5593 ExprResult ActOnCXXThrow(Scope *S, SourceLocation OpLoc, Expr *expr);
5594 ExprResult BuildCXXThrow(SourceLocation OpLoc, Expr *Ex,
5596 bool CheckCXXThrowOperand(SourceLocation ThrowLoc, QualType ThrowTy, Expr *E);
5620 Expr *Initializer);
5628 Optional<Expr *> ArraySize,
5630 Expr *Initializer);
5683 Expr *Operand);
5690 Expr *Operand, SourceLocation RParen);
5691 ExprResult BuildCXXNoexceptExpr(SourceLocation KeyLoc, Expr *Operand,
5707 Expr *DimExpr,
5713 Expr *DimExpr,
5720 Expr *Queried,
5725 Expr *Queried,
5729 Expr *Base,
5735 ExprResult BuildPseudoDestructorExpr(Expr *Base,
5744 ExprResult ActOnPseudoDestructorExpr(Scope *S, Expr *Base,
5753 ExprResult ActOnPseudoDestructorExpr(Scope *S, Expr *Base,
5762 Expr *MaybeCreateExprWithCleanups(Expr *SubExpr);
5762 Expr *MaybeCreateExprWithCleanups(Expr *SubExpr);
5767 CreateMaterializeTemporaryExpr(QualType T, Expr *Temporary,
5770 ExprResult ActOnFinishFullExpr(Expr *Expr, bool DiscardedValue) {
5774 ExprResult ActOnFinishFullExpr(Expr *Expr, SourceLocation CC,
5889 ExprResult ActOnDecltypeExpression(Expr *E);
6019 IdentifierInfo *Id, LambdaCaptureInitKind InitKind, Expr *&Init) {
6027 Expr *&Init);
6038 unsigned InitStyle, Expr *Init);
6128 Expr *Src);
6132 bool CheckConstraintExpression(Expr *CE);
6136 Expr *ConstraintExpr,
6147 ArrayRef<Expr *> Strings);
6154 ExprResult BuildObjCNumericLiteral(SourceLocation AtLoc, Expr *Number);
6164 ExprResult BuildObjCBoxedExpr(SourceRange SR, Expr *ValueExpr);
6166 ExprResult BuildObjCSubscriptExpression(SourceLocation RB, Expr *BaseExpr,
6167 Expr *IndexExpr,
6177 ExprResult BuildCXXMemberCallExpr(Expr *Exp, NamedDecl *FoundDecl,
6208 Expr *LangStr,
6230 Expr *BitfieldWidth, const VirtSpecifiers &VS,
6236 Expr *Init);
6246 ArrayRef<Expr *> Args,
6257 Expr *InitList,
6267 Expr *Init,
6271 Expr *Init,
6276 Expr *Init,
6281 Expr *Init,
6397 Expr *AssertExpr,
6398 Expr *AssertMessageExpr,
6401 Expr *AssertExpr,
6557 Expr *ObjectExpr,
6558 Expr *ArgExpr,
6560 AccessResult CheckAddressOfMemberAccess(Expr *OvlExpr,
6717 Expr *DefaultArg);
6736 Expr *RequiresClause);
6975 QualType InstantiatedParamType, Expr *Arg,
7081 ExprResult RebuildExprInCurrentInstantiation(Expr *E);
7097 IdentifierInfo *Name, SourceLocation NameLoc, Expr *ConstraintExpr);
7207 bool DiagnoseUnexpandedParameterPack(Expr *E,
7340 ExprResult ActOnPackExpansion(Expr *Pattern, SourceLocation EllipsisLoc);
7349 ExprResult CheckPackExpansion(Expr *Pattern, SourceLocation EllipsisLoc,
7557 TemplateArgumentListInfo *ExplicitTemplateArgs, ArrayRef<Expr *> Args,
7600 DeduceAutoType(TypeSourceInfo *AutoType, Expr *&Initializer, QualType &Result,
7603 DeduceAutoType(TypeLoc AutoTypeLoc, Expr *&Initializer, QualType &Result,
7605 void DiagnoseAutoDeductionFailure(VarDecl *VDecl, Expr *Init);
7621 Expr *Init);
7627 Expr *&RetExpr, AutoType *AT);
8339 ExprResult SubstExpr(Expr *E,
8355 bool SubstExprs(ArrayRef<Expr *> Exprs, bool IsCall,
8357 SmallVectorImpl<Expr *> &Outputs);
8369 ExprResult SubstInitializer(Expr *E,
8761 Expr *BaseExpr,
8828 ExprResult BuildInstanceMessage(Expr *Receiver,
8839 ExprResult BuildInstanceMessageImplicit(Expr *Receiver,
8847 Expr *Receiver,
8858 Expr *SubExpr);
8866 Expr *SubExpr);
8868 void CheckTollFreeBridgeCast(QualType castType, Expr *castExpr);
8870 void CheckObjCBridgeRelatedCast(QualType castType, Expr *castExpr);
8872 bool CheckTollFreeBridgeStaticCast(QualType castType, Expr *castExpr,
8885 Expr *&SrcExpr, bool Diagnose = true);
8887 bool ConversionToObjCStringLiteralCheck(QualType DstType, Expr *&SrcExpr,
8928 StringRef SlotLabel, Expr *Alignment);
9104 void AddAlignedAttr(Decl *D, const AttributeCommonInfo &CI, Expr *E,
9111 void AddAssumeAlignedAttr(Decl *D, const AttributeCommonInfo &CI, Expr *E,
9112 Expr *OE);
9117 Expr *ParamExpr);
9121 void AddAlignValueAttr(Decl *D, const AttributeCommonInfo &CI, Expr *E);
9126 Expr *MaxThreads, Expr *MinBlocks);
9126 Expr *MaxThreads, Expr *MinBlocks);
9142 Expr *Min, Expr *Max);
9142 Expr *Min, Expr *Max);
9147 Expr *Min, Expr *Max);
9147 Expr *Min, Expr *Max);
9156 ExprResult ActOnCoawaitExpr(Scope *S, SourceLocation KwLoc, Expr *E);
9157 ExprResult ActOnCoyieldExpr(Scope *S, SourceLocation KwLoc, Expr *E);
9158 StmtResult ActOnCoreturnStmt(Scope *S, SourceLocation KwLoc, Expr *E);
9160 ExprResult BuildResolvedCoawaitExpr(SourceLocation KwLoc, Expr *E,
9162 ExprResult BuildUnresolvedCoawaitExpr(SourceLocation KwLoc, Expr *E,
9164 ExprResult BuildCoyieldExpr(SourceLocation KwLoc, Expr *E);
9165 StmtResult BuildCoreturnStmt(SourceLocation KwLoc, Expr *E,
9239 bool checkOpenCLDisabledDecl(const NamedDecl &D, const Expr &E);
9252 VerifyPositiveIntegerConstantInClause(Expr *Op, OpenMPClauseKind CKind,
9281 void checkOpenMPDeviceExpr(const Expr *E);
9379 Expr *Op);
9406 ArrayRef<Expr *> VarList);
9409 ArrayRef<Expr *> VarList);
9412 ArrayRef<Expr *> VarList,
9433 void ActOnOpenMPDeclareReductionCombinerEnd(Decl *D, Expr *Combiner);
9438 void ActOnOpenMPDeclareReductionInitializerEnd(Decl *D, Expr *Initializer,
9481 checkDeclIsAllowedInOpenMPTarget(Expr *E, Decl *D,
9513 llvm::SmallDenseMap<const ValueDecl *, const Expr *, 4>;
9774 Expr *Simdlen, ArrayRef<Expr *> Uniforms, ArrayRef<Expr *> Aligneds,
9774 Expr *Simdlen, ArrayRef<Expr *> Uniforms, ArrayRef<Expr *> Aligneds,
9774 Expr *Simdlen, ArrayRef<Expr *> Uniforms, ArrayRef<Expr *> Aligneds,
9775 ArrayRef<Expr *> Alignments, ArrayRef<Expr *> Linears,
9775 ArrayRef<Expr *> Alignments, ArrayRef<Expr *> Linears,
9776 ArrayRef<unsigned> LinModifiers, ArrayRef<Expr *> Steps, SourceRange SR);
9786 Optional<std::pair<FunctionDecl *, Expr *>> checkOpenMPDeclareVariantFunction(
9787 DeclGroupPtrTy DG, Expr *VariantRef, SourceRange SR);
9798 FunctionDecl *FD, Expr *VariantRef, SourceRange SR,
9802 Expr *Expr,
9807 OMPClause *ActOnOpenMPAllocatorClause(Expr *Allocator,
9813 Expr *Condition, SourceLocation StartLoc,
9819 OMPClause *ActOnOpenMPFinalClause(Expr *Condition, SourceLocation StartLoc,
9823 OMPClause *ActOnOpenMPNumThreadsClause(Expr *NumThreads,
9828 OMPClause *ActOnOpenMPSafelenClause(Expr *Length,
9833 OMPClause *ActOnOpenMPSimdlenClause(Expr *Length, SourceLocation StartLoc,
9837 OMPClause *ActOnOpenMPCollapseClause(Expr *NumForLoops,
9845 Expr *NumForLoops = nullptr);
9847 OMPClause *ActOnOpenMPGrainsizeClause(Expr *Size, SourceLocation StartLoc,
9851 OMPClause *ActOnOpenMPNumTasksClause(Expr *NumTasks, SourceLocation StartLoc,
9855 OMPClause *ActOnOpenMPHintClause(Expr *Hint, SourceLocation StartLoc,
9879 OpenMPClauseKind Kind, ArrayRef<unsigned> Arguments, Expr *Expr,
9886 OpenMPScheduleClauseKind Kind, Expr *ChunkSize, SourceLocation StartLoc,
9947 OpenMPClauseKind Kind, ArrayRef<Expr *> Vars, Expr *TailExpr,
9947 OpenMPClauseKind Kind, ArrayRef<Expr *> Vars, Expr *TailExpr,
9957 ActOnOpenMPAllocateClause(Expr *Allocator, ArrayRef<Expr *> VarList,
9957 ActOnOpenMPAllocateClause(Expr *Allocator, ArrayRef<Expr *> VarList,
9961 OMPClause *ActOnOpenMPPrivateClause(ArrayRef<Expr *> VarList,
9966 OMPClause *ActOnOpenMPFirstprivateClause(ArrayRef<Expr *> VarList,
9971 OMPClause *ActOnOpenMPLastprivateClause(ArrayRef<Expr *> VarList,
9976 OMPClause *ActOnOpenMPSharedClause(ArrayRef<Expr *> VarList,
9982 ArrayRef<Expr *> VarList, SourceLocation StartLoc,
9986 ArrayRef<Expr *> UnresolvedReductions = llvm::None);
9989 ArrayRef<Expr *> VarList, SourceLocation StartLoc,
9993 ArrayRef<Expr *> UnresolvedReductions = llvm::None);
9996 ArrayRef<Expr *> VarList, SourceLocation StartLoc,
10000 ArrayRef<Expr *> UnresolvedReductions = llvm::None);
10003 ActOnOpenMPLinearClause(ArrayRef<Expr *> VarList, Expr *Step,
10003 ActOnOpenMPLinearClause(ArrayRef<Expr *> VarList, Expr *Step,
10008 OMPClause *ActOnOpenMPAlignedClause(ArrayRef<Expr *> VarList,
10009 Expr *Alignment,
10015 OMPClause *ActOnOpenMPCopyinClause(ArrayRef<Expr *> VarList,
10020 OMPClause *ActOnOpenMPCopyprivateClause(ArrayRef<Expr *> VarList,
10025 OMPClause *ActOnOpenMPFlushClause(ArrayRef<Expr *> VarList,
10032 SourceLocation ColonLoc, ArrayRef<Expr *> VarList,
10036 OMPClause *ActOnOpenMPDeviceClause(Expr *Device, SourceLocation StartLoc,
10047 ArrayRef<Expr *> VarList, const OMPVarListLocTy &Locs,
10048 ArrayRef<Expr *> UnresolvedMappers = llvm::None);
10050 OMPClause *ActOnOpenMPNumTeamsClause(Expr *NumTeams, SourceLocation StartLoc,
10054 OMPClause *ActOnOpenMPThreadLimitClause(Expr *ThreadLimit,
10059 OMPClause *ActOnOpenMPPriorityClause(Expr *Priority, SourceLocation StartLoc,
10064 OpenMPDistScheduleClauseKind Kind, Expr *ChunkSize,
10074 ActOnOpenMPToClause(ArrayRef<Expr *> VarList, CXXScopeSpec &MapperIdScopeSpec,
10077 ArrayRef<Expr *> UnresolvedMappers = llvm::None);
10080 ArrayRef<Expr *> VarList, CXXScopeSpec &MapperIdScopeSpec,
10082 ArrayRef<Expr *> UnresolvedMappers = llvm::None);
10084 OMPClause *ActOnOpenMPUseDevicePtrClause(ArrayRef<Expr *> VarList,
10087 OMPClause *ActOnOpenMPIsDevicePtrClause(ArrayRef<Expr *> VarList,
10112 ExprResult ImpCastExprToType(Expr *E, QualType Type, CastKind CK,
10125 ExprResult IgnoredValueConversions(Expr *E);
10129 ExprResult UsualUnaryConversions(Expr *E);
10133 ExprResult CallExprUnaryConversions(Expr *E);
10137 ExprResult DefaultFunctionArrayConversion(Expr *E, bool Diagnose = true);
10142 ExprResult DefaultFunctionArrayLvalueConversion(Expr *E,
10149 ExprResult DefaultLvalueConversion(Expr *E);
10154 ExprResult DefaultArgumentPromotion(Expr *E);
10159 ExprResult TemporaryMaterializationConversion(Expr *E);
10172 Expr *Fn);
10189 void checkVariadicArgument(const Expr *E, VariadicCallType CT);
10192 bool hasCStrMethod(const Expr *E);
10198 unsigned FirstParam, ArrayRef<Expr *> Args,
10199 SmallVectorImpl<Expr *> &AllArgs,
10206 ExprResult DefaultVariadicArgumentPromotion(Expr *E, VariadicCallType CT,
10301 Expr *SrcExpr, AssignmentAction Action,
10313 Expr *SrcExpr);
10353 bool IsStringLiteralToNonConstPointerConversion(Expr *From, QualType ToType);
10355 bool CheckExceptionSpecCompatibility(Expr *From, QualType ToType);
10357 ExprResult PerformImplicitConversion(Expr *From, QualType ToType,
10360 ExprResult PerformImplicitConversion(Expr *From, QualType ToType,
10364 ExprResult PerformImplicitConversion(Expr *From, QualType ToType,
10369 ExprResult PerformImplicitConversion(Expr *From, QualType ToType,
10375 Expr *E, QualType Ty, ExprValueKind VK = VK_RValue,
10418 Expr *LHSExpr, ExprResult &RHS, SourceLocation Loc, QualType CompoundType);
10421 UnaryOperatorKind Opcode, Expr *Op);
10424 Expr *LHS, Expr *RHS);
10424 Expr *LHS, Expr *RHS);
10425 ExprResult checkPseudoObjectRValue(Expr *E);
10426 Expr *recreateSyntacticForm(PseudoObjectExpr *E);
10434 QualType FindCompositePointerType(SourceLocation Loc, Expr *&E1, Expr *&E2,
10434 QualType FindCompositePointerType(SourceLocation Loc, Expr *&E1, Expr *&E2,
10439 Expr *E1Tmp = E1.get(), *E2Tmp = E2.get();
10450 bool DiagnoseConditionalForNull(Expr *LHSExpr, Expr *RHSExpr,
10450 bool DiagnoseConditionalForNull(Expr *LHSExpr, Expr *RHSExpr,
10453 void DiagnoseAlwaysNonNullPointer(Expr *E,
10454 Expr::NullPointerConstantKind NullType,
10472 bool CheckForConstantInitializer(Expr *e, QualType t);
10498 Expr *CastExpr, CastKind &CastKind,
10503 ExprResult forceUnknownAnyToType(Expr *E, QualType ToType);
10508 Expr *result, QualType ¶mType);
10519 ExprResult prepareVectorSplat(QualType VectorTy, Expr *SplattedExpr);
10526 ExprResult CheckExtVectorCast(SourceRange R, QualType DestTy, Expr *CastExpr,
10531 Expr *CastExpr,
10539 QualType castType, Expr *&op,
10546 Expr *stripARCUnbridgedCast(Expr *e);
10546 Expr *stripARCUnbridgedCast(Expr *e);
10547 void diagnoseARCUnbridgedCast(Expr *e);
10555 void checkRetainCycles(Expr *receiver, Expr *argument);
10555 void checkRetainCycles(Expr *receiver, Expr *argument);
10556 void checkRetainCycles(VarDecl *Var, Expr *Init);
10560 bool checkUnsafeAssigns(SourceLocation Loc, QualType LHS, Expr *RHS);
10564 void checkUnsafeExprAssigns(SourceLocation Loc, Expr *LHS, Expr *RHS);
10564 void checkUnsafeExprAssigns(SourceLocation Loc, Expr *LHS, Expr *RHS);
10570 bool CheckMessageArgumentTypes(const Expr *Receiver, QualType ReceiverType,
10581 QualType getMessageSendResultType(const Expr *Receiver, QualType ReceiverType,
10587 void EmitRelatedResultTypeNote(const Expr *E);
10616 std::pair<VarDecl *, Expr *> get() const {
10635 Expr *SubExpr, ConditionKind CK);
10646 ExprResult CheckSwitchCondition(SourceLocation SwitchLoc, Expr *Cond);
10656 ExprResult CheckBooleanCondition(SourceLocation Loc, Expr *E,
10661 ExplicitSpecifier ActOnExplicitBoolSpecifier(Expr *E);
10669 void DiagnoseAssignmentAsCondition(Expr *E);
10676 ExprResult CheckCXXBooleanCondition(Expr *CondExpr, bool IsConstexpr = false);
10706 ExprResult VerifyIntegerConstantExpression(Expr *E, llvm::APSInt *Result,
10709 ExprResult VerifyIntegerConstantExpression(Expr *E, llvm::APSInt *Result,
10712 ExprResult VerifyIntegerConstantExpression(Expr *E,
10721 Expr *BitWidth, bool *ZeroWidth = nullptr);
11113 void CodeCompleteMemberReferenceExpr(Scope *S, Expr *Base, Expr *OtherOpBase,
11113 void CodeCompleteMemberReferenceExpr(Scope *S, Expr *Base, Expr *OtherOpBase,
11127 QualType ProduceCallSignatureHelp(Scope *S, Expr *Fn, ArrayRef<Expr *> Args,
11127 QualType ProduceCallSignatureHelp(Scope *S, Expr *Fn, ArrayRef<Expr *> Args,
11131 ArrayRef<Expr *> Args,
11136 ArrayRef<Expr *> ArgExprs,
11174 void CodeCompleteObjCInstanceMessage(Scope *S, Expr *Receiver,
11233 void CheckArrayAccess(const Expr *BaseExpr, const Expr *IndexExpr,
11233 void CheckArrayAccess(const Expr *BaseExpr, const Expr *IndexExpr,
11236 void CheckArrayAccess(const Expr *E);
11250 ArrayRef<const Expr *> Args);
11255 ArrayRef<const Expr *> Args,
11260 const Expr *ThisArg, ArrayRef<const Expr *> Args,
11260 const Expr *ThisArg, ArrayRef<const Expr *> Args,
11264 bool CheckObjCString(Expr *Arg);
11265 ExprResult CheckOSLogFormatStringArg(Expr *Arg);
11299 ExprResult SemaConvertVectorExpr(Expr *E, TypeSourceInfo *TInfo,
11350 ArrayRef<const Expr *> Args,
11355 bool CheckFormatArguments(ArrayRef<const Expr *> Args,
11377 void CheckReturnValExpr(Expr *RetValExp, QualType lhsType,
11384 void CheckFloatComparison(SourceLocation Loc, Expr *LHS, Expr *RHS);
11384 void CheckFloatComparison(SourceLocation Loc, Expr *LHS, Expr *RHS);
11387 void CheckImplicitConversions(Expr *E, SourceLocation CC = SourceLocation());
11388 void CheckBoolLikeConversion(Expr *E, SourceLocation CC);
11389 void CheckForIntOverflow(Expr *E);
11390 void CheckUnsequencedOperations(Expr *E);
11394 void CheckCompletedExpr(Expr *E, SourceLocation CheckLoc = SourceLocation(),
11398 Expr *Init);
11408 void CheckBreakContinueBinding(Expr *E);
11451 const ArrayRef<const Expr *> ExprArgs,
11456 void CheckAddressOfPackedMember(Expr *rhs);
11577 Expr *E;
11583 MisalignedMember(Expr *E, RecordDecl *RD, ValueDecl *MD,
11586 explicit MisalignedMember(Expr *E)
11596 void AddPotentialMisalignedMembers(Expr *E, RecordDecl *RD, ValueDecl *MD,
11610 void DiscardMisalignedMemberAddress(const Type *T, Expr *E);
11616 Expr *E,
11617 llvm::function_ref<void(Expr *, RecordDecl *, FieldDecl *, CharUnits)>
tools/clang/include/clang/Sema/SemaFixItUtils.h 75 bool tryToFixConversion(const Expr *FromExpr,
tools/clang/include/clang/Serialization/ASTReader.h 2271 Expr *ReadExpr(ModuleFile &F);
2284 Expr *ReadSubExpr();
2468 Expr *readExpr() { return Reader->ReadExpr(*F); }
2474 Expr *readSubExpr() { return Reader->ReadSubExpr(); }
tools/clang/include/clang/Serialization/ASTWriter.h 728 Expr *ThisArg) override;
tools/clang/include/clang/StaticAnalyzer/Core/BugReporter/BugReporter.h 106 virtual std::string getMessageForArg(const Expr *ArgE, unsigned ArgIndex);
tools/clang/include/clang/StaticAnalyzer/Core/BugReporter/BugReporterVisitors.h 114 bool trackExpressionValue(const ExplodedNode *N, const Expr *E,
119 const Expr *getDerefExpr(const Stmt *S);
209 static const Expr *getNilReceiver(const Stmt *S, const ExplodedNode *N);
243 PathDiagnosticPieceRef VisitTrueTest(const Expr *Cond,
248 PathDiagnosticPieceRef VisitTrueTest(const Expr *Cond, const DeclRefExpr *DR,
255 VisitTrueTest(const Expr *Cond, const BinaryOperator *BExpr,
259 PathDiagnosticPieceRef VisitTrueTest(const Expr *Cond, const MemberExpr *ME,
266 VisitConditionVariable(StringRef LhsString, const Expr *CondVarExpr,
279 bool printValue(const Expr *CondVarExpr, raw_ostream &Out,
282 bool patternMatch(const Expr *Ex,
283 const Expr *ParentEx,
tools/clang/include/clang/StaticAnalyzer/Core/Checker.h 104 ((const CHECKER *)checker)->checkPostStmt(cast<STMT>(S), C);
108 return isa<STMT>(S);
tools/clang/include/clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h 145 llvm::PointerUnion<const Expr *, const Decl *> Origin;
167 CallEvent(const Expr *E, ProgramStateRef state, const LocationContext *lctx)
222 const Expr *getOriginExpr() const {
223 return Origin.dyn_cast<const Expr *>();
272 virtual const Expr *getArgExpr(unsigned Index) const { return nullptr; }
463 AnyFunctionCall(const Expr *E, ProgramStateRef St,
518 const Expr *getArgExpr(unsigned Index) const override {
553 const Expr *getArgExpr(unsigned Index) const override {
653 virtual const Expr *getCXXThisExpr() const { return nullptr; }
696 const Expr *getArgExpr(unsigned Index) const override {
700 const Expr *getCXXThisExpr() const override;
737 const Expr *getArgExpr(unsigned Index) const override {
741 const Expr *getCXXThisExpr() const override;
852 const Expr *getArgExpr(unsigned Index) const override {
903 const Expr *getArgExpr(unsigned Index) const override {
914 const Expr *getPlacementArgExpr(unsigned Index) const {
974 const Expr *getArgExpr(unsigned Index) const override {
tools/clang/include/clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h 150 bool isGreaterOrEqual(const Expr *E, unsigned long long Val);
153 bool isNegative(const Expr *E);
tools/clang/include/clang/StaticAnalyzer/Core/PathSensitive/CheckerHelpers.h 43 std::pair<const clang::VarDecl *, const clang::Expr *>
tools/clang/include/clang/StaticAnalyzer/Core/PathSensitive/CoreEngine.h 481 const Expr *E;
486 const Expr *e, const CFGBlock *dispatch, CoreEngine* eng)
516 const Expr *getTarget() const { return E; }
528 const Expr *Condition;
533 const Expr *condition, CoreEngine* eng)
570 const Expr *getCondition() const { return Condition; }
tools/clang/include/clang/StaticAnalyzer/Core/PathSensitive/ExplodedGraph.h 456 static bool isInterestingLValueExpr(const Expr *Ex);
tools/clang/include/clang/StaticAnalyzer/Core/PathSensitive/ExprEngine.h 446 void VisitCast(const CastExpr *CastE, const Expr *Ex, ExplodedNode *Pred,
454 void VisitCommonDeclRefExpr(const Expr *DR, const NamedDecl *D,
462 void VisitGuardedExpr(const Expr *Ex, const Expr *L, const Expr *R,
462 void VisitGuardedExpr(const Expr *Ex, const Expr *L, const Expr *R,
462 void VisitGuardedExpr(const Expr *Ex, const Expr *L, const Expr *R,
554 const Expr *Ex);
567 ProgramStateRef handleLValueBitCast(ProgramStateRef state, const Expr *Ex,
643 const Expr *NodeEx, /* Eventually will be a CFGStmt */
644 const Expr *BoundExpr,
653 void evalStore(ExplodedNodeSet &Dst, const Expr *AssignE, const Expr *StoreE,
653 void evalStore(ExplodedNodeSet &Dst, const Expr *AssignE, const Expr *StoreE,
686 const Expr *NodeEx, /* Eventually will be a CFGStmt */
687 const Expr *BoundEx,
776 const Expr *InitWithAdjustments, const Expr *Result = nullptr,
776 const Expr *InitWithAdjustments, const Expr *Result = nullptr,
804 const Expr *E, ProgramStateRef State, const LocationContext *LCtx,
tools/clang/include/clang/StaticAnalyzer/Core/PathSensitive/MemRegion.h 479 const Expr *Ex;
481 AllocaRegion(const Expr *ex, unsigned cnt, const MemSpaceRegion *superRegion)
486 static void ProfileRegion(llvm::FoldingSetNodeID& ID, const Expr *Ex,
490 const Expr *getExpr() const { return Ex; }
1125 Expr const *Ex;
1127 CXXTempObjectRegion(Expr const *E, MemSpaceRegion const *sReg)
1135 Expr const *E, const MemRegion *sReg);
1138 const Expr *getExpr() const { return Ex; }
1299 const AllocaRegion *getAllocaRegion(const Expr *Ex, unsigned Cnt,
1362 const CXXTempObjectRegion *getCXXTempObjectRegion(Expr const *Ex,
1406 const CXXTempObjectRegion *getCXXStaticTempObjectRegion(const Expr *Ex);
tools/clang/include/clang/StaticAnalyzer/Core/PathSensitive/ProgramState.h 283 invalidateRegions(ArrayRef<const MemRegion *> Regions, const Expr *E,
290 invalidateRegions(ArrayRef<SVal> Regions, const Expr *E,
444 const Expr *E, unsigned BlockCount,
766 if (const Expr *Ex = dyn_cast<Expr>(S)) {
766 if (const Expr *Ex = dyn_cast<Expr>(S)) {
tools/clang/include/clang/StaticAnalyzer/Core/PathSensitive/SValBuilder.h 187 const SymbolConjured* conjureSymbol(const Expr *expr,
207 const Expr *expr,
211 const Expr *expr,
223 DefinedOrUnknownSVal getConjuredHeapSymbolVal(const Expr *E,
232 const Expr *expr, QualType type,
248 Optional<SVal> getConstantVal(const Expr *E);
tools/clang/include/clang/StaticAnalyzer/Core/PathSensitive/Store.h 236 const Expr *E, unsigned Count,
tools/clang/include/clang/StaticAnalyzer/Core/PathSensitive/SymbolManager.h 492 const SymbolConjured* conjureSymbol(const Expr *E,
tools/clang/include/clang/Tooling/FixIt.h 43 template <typename T> CharSourceRange getSourceRange(const T &Node) {
50 StringRef getText(const T &Node, const ASTContext &Context) {
56 template <typename T> FixItHint createRemoval(const T &Node) {
62 FixItHint createReplacement(const D &Destination, const S &Source,
62 FixItHint createReplacement(const D &Destination, const S &Source,
70 FixItHint createReplacement(const D &Destination, StringRef Source) {
tools/clang/include/clang/Tooling/Transformer/SourceCode.h 32 CharSourceRange getExtendedRange(const T &Node, tok::TokenKind Next,
43 StringRef getText(const T &Node, const ASTContext &Context) {
71 StringRef getExtendedText(const T &Node, tok::TokenKind Next,
tools/clang/include/clang/Tooling/Transformer/SourceCodeBuilders.h 28 const Expr *reallyIgnoreImplicit(const Expr &E);
28 const Expr *reallyIgnoreImplicit(const Expr &E);
33 bool mayEverNeedParens(const Expr &E);
39 inline bool needParensBeforeDotOrArrow(const Expr &E) {
45 bool needParensAfterUnaryOperator(const Expr &E);
53 llvm::Optional<std::string> buildParens(const Expr &E,
58 llvm::Optional<std::string> buildDereference(const Expr &E,
63 llvm::Optional<std::string> buildAddressOf(const Expr &E,
72 llvm::Optional<std::string> buildDot(const Expr &E, const ASTContext &Context);
80 llvm::Optional<std::string> buildArrow(const Expr &E,
tools/clang/lib/ARCMigrate/ObjCMT.cpp 227 bool subscriptOperatorNeedsParens(const Expr *FullExpr) {
228 const Expr* Expr = FullExpr->IgnoreImpCasts();
250 if (const Expr *Receiver = Msg->getInstanceReceiver())
268 const Expr *receiver = Msg->getInstanceReceiver();
300 const Expr*const* Args = Msg->getArgs();
301 const Expr *RHS = Args[0];
807 const Expr *InitExpr = Enumerator->getInitExpr();
tools/clang/lib/ARCMigrate/TransAPIUses.cpp 71 Expr *parm = E->getArg(0)->IgnoreParenCasts();
tools/clang/lib/ARCMigrate/TransARCAssign.cpp 45 Expr *E = Exp->getLHS();
51 Expr::isModifiableLvalueResult IsLV = E->isModifiableLvalue(Ctx, &Loc);
52 if (IsLV != Expr::MLV_ConstQualified)
tools/clang/lib/ARCMigrate/TransAutoreleasePool.cpp 55 Expr *instance = E->getInstanceReceiver()->IgnoreParenCasts();
349 bool isPoolCreation(Expr *E) {
360 Expr *rec = getEssential(ME->getInstanceReceiver());
378 Expr *rec = getEssential(ME->getInstanceReceiver());
401 static Expr *getEssential(Expr *E) {
401 static Expr *getEssential(Expr *E) {
402 return cast<Expr>(getEssential((Stmt*)E));
407 if (Expr *E = dyn_cast<Expr>(S))
407 if (Expr *E = dyn_cast<Expr>(S))
tools/clang/lib/ARCMigrate/TransEmptyStatementsAndDealloc.cpp 98 Expr *condE = S->getCond();
110 Expr *condE = S->getCond();
120 Expr *condE = S->getCond();
130 Expr *Exp = S->getCollection();
tools/clang/lib/ARCMigrate/TransGCCalls.cpp 45 Expr *CEE = E->getCallee()->IgnoreParenImpCasts();
tools/clang/lib/ARCMigrate/TransProperties.cpp 291 Expr *lhs = E->getLHS()->IgnoreParenImpCasts();
tools/clang/lib/ARCMigrate/TransRetainReleaseDealloc.cpp 85 if (Expr *rec = E->getInstanceReceiver()) {
135 Expr *rec = E->getInstanceReceiver();
142 Expr *RecContainer = Msg;
183 Expr *Rec = E->getInstanceReceiver();
204 Expr *Rec = E->getInstanceReceiver();
240 Stmt *getNextStmt(Expr *E) {
244 std::pair<Stmt *, Stmt *> getPreviousAndNextStmt(Expr *E) {
272 if (auto *E = dyn_cast_or_null<Expr>(prevStmt))
272 if (auto *E = dyn_cast_or_null<Expr>(prevStmt))
283 if (auto *E = dyn_cast_or_null<Expr>(nextStmt))
283 if (auto *E = dyn_cast_or_null<Expr>(nextStmt))
289 Decl *getReferencedDecl(Expr *E) {
325 void checkForGCDOrXPC(ObjCMessageExpr *Msg, Expr *&RecContainer,
326 Expr *&Rec, SourceRange &RecRange) {
373 Expr *Init = VD->getInit();
395 bool isDelegateMessage(Expr *E) const {
410 bool isInAtFinally(Expr *E) const {
422 bool isRemovable(Expr *E) const {
426 bool tryRemoving(Expr *E) const {
tools/clang/lib/ARCMigrate/TransUnbridgedCasts.cpp 94 Expr *castExpr = E->getSubExpr();
105 Expr::NPC_ValueDependentIsNull))
133 Expr *inner = E->IgnoreParenCasts();
159 Expr *Arg = callE->getArg(0);
161 const Expr *sub = ICE->getSubExpr();
181 Expr *base = inner->IgnoreParenImpCasts();
251 Expr *WrapE = E->getSubExpr();
315 if (tryRemoving(cast<Expr>(StmtMap->getParentIgnoreParenCasts(E))))
321 bool tryRemoving(Expr *E) const {
385 Expr *subExpr = E->getSubExpr();
406 static ObjCMethodFamily getFamilyOfMessage(Expr *E) {
414 bool isPassedToCFRetain(Expr *E, CallExpr *&callE) const {
427 bool isPassedToCParamWithKnownOwnership(Expr *E, bool &isConsumed) const {
434 Expr *arg = callE->getArg(i);
450 bool isSelf(Expr *E) const {
tools/clang/lib/ARCMigrate/TransUnusedInitDelegate.cpp 67 bool isRemovable(Expr *E) const {
tools/clang/lib/ARCMigrate/TransZeroOutPropsInDealloc.cpp 48 Expr *receiver = ME->getInstanceReceiver();
71 Expr *RHS = ME->getArg(0);
74 Expr::NPC_ValueDependentIsNull);
147 bool isRemovable(Expr *E) const {
151 bool isZeroingPropIvar(Expr *E) {
168 Expr *LHS = BOE->getLHS();
213 bool isZero(Expr *E) {
214 if (E->isNullPointerConstant(Pass.Ctx, Expr::NPC_ValueDependentIsNull))
tools/clang/lib/ARCMigrate/TransformActions.cpp 316 if (auto *E = dyn_cast<Expr>(S))
316 if (auto *E = dyn_cast<Expr>(S))
455 if (Expr *E = dyn_cast<Expr>(S)) {
455 if (Expr *E = dyn_cast<Expr>(S)) {
tools/clang/lib/ARCMigrate/Transforms.cpp 73 bool trans::isPlusOne(const Expr *E) {
167 bool trans::hasSideEffects(Expr *E, ASTContext &Ctx) {
196 bool trans::isGlobalVar(Expr *E) {
291 if (auto *E = dyn_cast<Expr>(S))
291 if (auto *E = dyn_cast<Expr>(S))
293 if (auto *E = dyn_cast<Expr>(S))
293 if (auto *E = dyn_cast<Expr>(S))
tools/clang/lib/ARCMigrate/Transforms.h 163 bool isPlusOne(const Expr *E);
179 bool hasSideEffects(Expr *E, ASTContext &Ctx);
180 bool isGlobalVar(Expr *E);
205 typedef llvm::DenseSet<Expr *> ExprSet;
tools/clang/lib/AST/APValue.cpp 42 APValue::LValueBase::LValueBase(const Expr *P, unsigned I, unsigned V)
560 Base.get<const Expr*>()->printPretty(Out, nullptr,
591 const Expr *E = Base.get<const Expr*>();
591 const Expr *E = Base.get<const Expr*>();
tools/clang/lib/AST/ASTContext.cpp 743 Expr *const CanonRequiresClause = nullptr;
2580 bool ASTContext::isSentinelNullExpr(const Expr *E) {
2589 Expr::NPC_ValueDependentIsNull))
2669 void ASTContext::setBlockVarCopyInit(const VarDecl*VD, Expr *CopyExpr,
3169 const Expr *SizeExpr,
3211 ConstantArrayType::totalSizeToAlloc<const Expr *>(SizeExpr ? 1 : 0),
3360 Expr *NumElts,
3388 Expr *numElements,
3523 ASTContext::getDependentVectorType(QualType VecType, Expr *SizeExpr,
3594 Expr *SizeExpr,
3635 Expr *AddrSpaceExpr,
3881 FunctionType::ExceptionType, Expr *, FunctionDecl *,
4446 Expr *E = new (*this) DeclRefExpr(
4449 Expr::getValueKindForType(NTTP->getType()), NTTP->getLocation());
4871 QualType ASTContext::getTypeOfExprType(Expr *tofExpr) const {
4916 QualType ASTContext::getDecltypeType(Expr *e, QualType UnderlyingType) const {
5790 QualType ASTContext::isPromotableBitField(Expr *E) const {
6194 const Expr *copyExpr = getBlockVarCopyInit(D).getCopyExpr();
9069 Expr *E = VAT->getSizeExpr();
tools/clang/lib/AST/ASTDiagnostic.cpp 547 Expr *ArgExpr = nullptr;
619 void SetExpressionDiff(Expr *FromExpr, Expr *ToExpr, bool FromDefault,
619 void SetExpressionDiff(Expr *FromExpr, Expr *ToExpr, bool FromDefault,
640 Expr *FromExpr, Expr *ToExpr, bool FromDefault,
640 Expr *FromExpr, Expr *ToExpr, bool FromDefault,
657 bool FromNullPtr, bool ToNullPtr, Expr *FromExpr,
658 Expr *ToExpr, bool FromDefault, bool ToDefault) {
674 Expr *FromExpr, const llvm::APSInt &ToInt, bool IsValidToInt,
675 QualType ToIntType, Expr *ToExpr, bool FromDefault, bool ToDefault) {
691 Expr *FromExpr, ValueDecl *ToValueDecl, bool ToAddressOf,
692 bool ToNullPtr, Expr *ToExpr, bool FromDefault, bool ToDefault) {
781 void GetExpressionDiff(Expr *&FromExpr, Expr *&ToExpr) {
781 void GetExpressionDiff(Expr *&FromExpr, Expr *&ToExpr) {
796 Expr *&FromExpr, Expr *&ToExpr) {
796 Expr *&FromExpr, Expr *&ToExpr) {
810 bool &FromNullPtr, bool &ToNullPtr, Expr *&FromExpr,
811 Expr *&ToExpr) {
825 Expr *&FromExpr, llvm::APSInt &ToInt, bool &IsValidToInt,
826 QualType &ToIntType, Expr *&ToExpr) {
841 Expr *&FromExpr, ValueDecl *&ToValueDecl, bool &ToAddressOf,
842 bool &ToNullPtr, Expr *&ToExpr) {
1165 Expr *&E, ValueDecl *&VD,
1233 Expr *FromExpr = nullptr, *ToExpr = nullptr;
1427 static bool IsEqualExpr(ASTContext &Context, Expr *FromExpr, Expr *ToExpr) {
1427 static bool IsEqualExpr(ASTContext &Context, Expr *FromExpr, Expr *ToExpr) {
1465 Expr *FromExpr, *ToExpr;
1480 Expr *FromExpr, *ToExpr;
1494 Expr *FromExpr, *ToExpr;
1507 Expr *FromExpr;
1511 Expr *ToExpr;
1525 Expr *FromExpr;
1529 Expr *ToExpr;
1666 void PrintExpr(const Expr *FromExpr, const Expr *ToExpr, bool FromDefault,
1666 void PrintExpr(const Expr *FromExpr, const Expr *ToExpr, bool FromDefault,
1691 void PrintExpr(const Expr *E) {
1736 QualType ToIntType, Expr *FromExpr, Expr *ToExpr,
1736 QualType ToIntType, Expr *FromExpr, Expr *ToExpr,
1767 void PrintAPSInt(const llvm::APSInt &Val, Expr *E, bool Valid,
1801 bool HasExtraInfo(Expr *E) {
1819 void PrintValueDecl(ValueDecl *VD, bool AddressOf, Expr *E, bool NullPtr) {
1850 bool ToNullPtr, Expr *FromExpr, Expr *ToExpr,
1850 bool ToNullPtr, Expr *FromExpr, Expr *ToExpr,
1878 bool IsNullPtr, Expr *VDExpr, bool DefaultDecl,
1880 Expr *IntExpr, bool DefaultInt) {
1900 Expr *IntExpr, bool DefaultInt, ValueDecl *VD,
1902 Expr *VDExpr, bool DefaultDecl) {
tools/clang/lib/AST/ASTImporter.cpp 80 using ExpectedExpr = llvm::Expected<Expr *>;
162 Expected<T *> import(T *From) {
162 Expected<T *> import(T *From) {
166 return cast_or_null<T>(*ToOrErr);
170 Expected<T *> import(const T *From) {
170 Expected<T *> import(const T *From) {
544 ExpectedStmt VisitExpr(Expr *E);
1102 const Expr *ToSizeExpr;
1127 Expr *ToSizeExpr;
1143 Expr *ToSizeExpr;
1898 Expr *FromInit = From->getInit();
2158 Expr *ToAssertExpr;
3158 Expr *ExplicitExpr = nullptr;
3183 Expr *ToThisArg;
3197 Expr *ExplicitExpr = nullptr;
3388 if (Expr *FromInitializer = D->getInClassInitializer()) {
3418 Expr *ToBitWidth;
3420 Expr *ToInitializer;
3620 Expr *ToBitWidth;
5688 SmallVector<Expr *, 4> Exprs(S->getNumOutputs() + S->getNumInputs() +
5774 Expr *ToLHS, *ToRHS;
5840 Expr *ToCond;
5859 Expr *ToCond;
5892 Expr *ToCond;
5909 Expr *ToCond;
5925 Expr *ToCond, *ToInc;
5958 Expr *ToTarget;
5986 Expr *ToRetValue;
6043 Expr *ToCond, *ToInc;
6065 Expr *ToCollection;
6136 Expr *ToSynchExpr;
6170 ExpectedStmt ASTNodeImporter::VisitExpr(Expr *E) {
6184 Expr *ToSubExpr;
6201 Expr *ToCond;
6202 Expr *ToLHS;
6203 Expr *ToRHS;
6307 SmallVector<Expr *, 4> ToIndexExprs(E->getNumSubExprs() - 1);
6419 Expr *ToInitializer;
6437 SmallVector<Expr *, 6> ToExprs(E->getNumSubExprs());
6467 Expr *ToSubExpr;
6486 Expr *ToSubExpr;
6494 SmallVector<Expr *, 4> ToExprs(E->getNumExprs());
6531 Expr *ToSubExpr;
6576 Expr *ToLHS, *ToRHS;
6593 Expr *ToCond, *ToLHS, *ToRHS;
6611 Expr *ToCommon, *ToCond, *ToTrueExpr, *ToFalseExpr;
6634 Expr *ToDimensionExpression;
6652 Expr *ToQueriedExpression;
6669 Expr *ToSourceExpr;
6682 Expr *ToLHS, *ToRHS;
6700 Expr *ToLHS, *ToRHS;
6749 Expr *ToSubExpr;
6845 SmallVector<Expr *, 4> ToExprs(E->getNumExpressions());
6876 Expr *ToOperand;
6895 Expr *ToSubExpr;
6981 SmallVector<Expr *, 8> ToArgs(E->getNumArgs());
7000 Expr *ToTemporaryExpr;
7019 Expr *ToPattern;
7067 Optional<Expr *> ToArraySize;
7068 Expr *ToInitializer;
7075 SmallVector<Expr *, 4> ToPlacementArgs(E->getNumPlacementArgs());
7096 Expr *ToArgument;
7119 SmallVector<Expr *, 6> ToArgs(E->getNumArgs());
7151 Expr *ToCallee;
7156 SmallVector<Expr *, 4> ToArgs(E->getNumArgs());
7197 Expr *ToBase;
7245 Expr *ToBase;
7288 Expr *ToBase = nullptr;
7365 SmallVector<Expr *, 8> ToArgs(E->arg_size());
7461 Expr *ToBase = nullptr;
7480 Expr *ToCallee;
7486 llvm::SmallVector<Expr *, 2> ToArgs(NumArgs);
7522 SmallVector<Expr *, 8> ToCaptureInits(E->capture_size());
7552 SmallVector<Expr *, 4> ToExprs(E->getNumInits());
7625 Expr *ToCommonExpr, *ToSubExpr;
7664 Expr *ToSubExpr;
7710 Expr *ToReplacement;
8118 Expected<Expr *> ASTImporter::Import(Expr *FromE) {
8118 Expected<Expr *> ASTImporter::Import(Expr *FromE) {
8120 return cast_or_null<Expr>(*ToSOrErr);
8140 if (auto *ToE = dyn_cast<Expr>(*ToSOrErr)) {
8140 if (auto *ToE = dyn_cast<Expr>(*ToSOrErr)) {
8141 auto *FromE = cast<Expr>(FromS);
8141 auto *FromE = cast<Expr>(FromS);
tools/clang/lib/AST/ASTStructuralEquivalence.cpp 160 const Expr *E1, const Expr *E2) {
160 const Expr *E1, const Expr *E2) {
tools/clang/lib/AST/Decl.cpp 2006 if (const Expr *Init = getInit()) {
2201 const Expr *VarDecl::getAnyInitializer(const VarDecl *&D) const {
2219 Expr *VarDecl::getInit() {
2224 return cast<Expr>(S);
2226 return cast_or_null<Expr>(Init.get<EvaluatedStmt *>()->Value);
2268 void VarDecl::setInit(Expr *I) {
2313 const Expr *Init = getAnyInitializer(DefVD);
2356 const auto *Init = cast<Expr>(Eval->Value);
2356 const auto *Init = cast<Expr>(Eval->Value);
2424 const auto *Init = cast<Expr>(Eval->Value);
2424 const auto *Init = cast<Expr>(Eval->Value);
2661 StorageClass S, Expr *DefArg) {
2695 Expr *ParmVarDecl::getDefaultArg() {
2700 Expr *Arg = getInit();
2707 void ParmVarDecl::setDefaultArg(Expr *defarg) {
2723 if (const Expr *E = getInit())
2732 void ParmVarDecl::setUninstantiatedDefaultArg(Expr *arg) {
2737 Expr *ParmVarDecl::getUninstantiatedDefaultArg() {
2740 return cast_or_null<Expr>(Init.get<Stmt *>());
3930 TypeSourceInfo *TInfo, Expr *BW, bool Mutable,
4016 const Expr *FinalExpr = getInClassInitializer();
4676 Expr *E, const llvm::APSInt &V) {
tools/clang/lib/AST/DeclCXX.cpp 2057 CXXMethodDecl *CXXMethodDecl::getDevirtualizedMethod(const Expr *Base,
2356 SourceLocation L, Expr *Init,
2366 SourceLocation L, Expr *Init,
2375 SourceLocation L, Expr *Init,
2383 SourceLocation L, Expr *Init,
2423 if (Expr *I = D->getInClassInitializer())
2491 Expr *E = (*init_begin())->getInit()->IgnoreImplicit();
2618 void CXXDestructorDecl::setOperatorDelete(FunctionDecl *OD, Expr *ThisArg) {
2973 Expr *AssertExpr,
3005 Expr *B = getBinding();
tools/clang/lib/AST/DeclObjC.cpp 1751 AccessControl ac, Expr *BW,
1827 IdentifierInfo *Id, QualType T, Expr *BW) {
tools/clang/lib/AST/DeclOpenMP.cpp 31 ArrayRef<Expr *> VL) {
33 new (C, DC, additionalSizeToAlloc<Expr *>(VL.size()))
43 OMPThreadPrivateDecl *D = new (C, ID, additionalSizeToAlloc<Expr *>(N))
49 void OMPThreadPrivateDecl::setVars(ArrayRef<Expr *> VL) {
52 std::uninitialized_copy(VL.begin(), VL.end(), getTrailingObjects<Expr *>());
62 SourceLocation L, ArrayRef<Expr *> VL,
65 C, DC, additionalSizeToAlloc<Expr *, OMPClause *>(VL.size(), CL.size()))
78 new (C, ID, additionalSizeToAlloc<Expr *, OMPClause *>(NVars, NClauses))
85 void OMPAllocateDecl::setVars(ArrayRef<Expr *> VL) {
88 std::uninitialized_copy(VL.begin(), VL.end(), getTrailingObjects<Expr *>());
tools/clang/lib/AST/DeclPrinter.cpp 324 Expr *Init = BMInitializer->getInit();
330 Expr *SimpleInit = nullptr;
331 Expr **Args = nullptr;
563 if (Expr *Init = D->getInitExpr()) {
816 Expr *Init = D->getInClassInitializer();
867 Expr *Init = D->getInit();
1668 if (auto *Init = D->getInitializer()) {
tools/clang/lib/AST/DeclTemplate.cpp 50 Expr *RequiresClause)
72 *getTrailingObjects<Expr *>() = RequiresClause;
82 SourceLocation RAngleLoc, Expr *RequiresClause) {
83 void *Mem = C.Allocate(totalSizeToAlloc<NamedDecl *, Expr *>(
142 getAssociatedConstraints(llvm::SmallVectorImpl<const Expr *> &AC) const {
173 getAssociatedConstraints(llvm::SmallVectorImpl<const Expr *> &AC) const {
855 Expr *ConstraintExpr) {
tools/clang/lib/AST/Expr.cpp 37 const Expr *Expr::getBestDynamicClassTypeExpr() const {
38 const Expr *E = this;
63 const Expr *E = getBestDynamicClassTypeExpr();
76 const Expr *Expr::skipRValueSubobjectAdjustments(
77 SmallVectorImpl<const Expr *> &CommaLHSs,
79 const Expr *E = this;
135 const Expr *E = IgnoreParens();
205 SourceLocation getExprLocImpl(const Expr *expr,
215 SourceLocation getExprLocImpl(const Expr *expr,
274 ConstantExpr::ConstantExpr(Expr *subexpr, ResultStorageKind StorageKind)
279 ConstantExpr *ConstantExpr::Create(const ASTContext &Context, Expr *E,
291 ConstantExpr *ConstantExpr::Create(const ASTContext &Context, Expr *E,
430 if (const Expr *Init = Var->getAnyInitializer())
1335 CallExpr::CallExpr(StmtClass SC, Expr *Fn, ArrayRef<Expr *> PreArgs,
1335 CallExpr::CallExpr(StmtClass SC, Expr *Fn, ArrayRef<Expr *> PreArgs,
1336 ArrayRef<Expr *> Args, QualType Ty, ExprValueKind VK,
1381 CallExpr *CallExpr::Create(const ASTContext &Ctx, Expr *Fn,
1382 ArrayRef<Expr *> Args, QualType Ty, ExprValueKind VK,
1394 CallExpr *CallExpr::CreateTemporary(void *Mem, Expr *Fn, QualType Ty,
1429 void CallExpr::updateDependenciesFromArg(Expr *Arg) {
1441 Expr *CEE = IgnoreParenImpCasts();
1497 const Expr *Callee = getCallee();
1508 CalleeType = Expr::findBoundMemberType(Callee);
1551 ArrayRef<Expr*> exprs,
1554 totalSizeToAlloc<OffsetOfNode, Expr *>(comps.size(), exprs.size()));
1563 C.Allocate(totalSizeToAlloc<OffsetOfNode, Expr *>(numComps, numExprs));
1569 ArrayRef<OffsetOfNode> comps, ArrayRef<Expr*> exprs,
1602 UnaryExprOrTypeTrait ExprKind, Expr *E, QualType resultType,
1639 MemberExpr::MemberExpr(Expr *Base, bool IsArrow, SourceLocation OperatorLoc,
1660 const ASTContext &C, Expr *Base, bool IsArrow, SourceLocation OperatorLoc,
1891 const Expr *skipImplicitTemporary(const Expr *E) {
1891 const Expr *skipImplicitTemporary(const Expr *E) {
1904 Expr *CastExpr::getSubExprAsWritten() {
1905 const Expr *SubExpr = nullptr;
1931 const Expr *SubExpr = nullptr;
1982 CastKind Kind, Expr *Operand,
2008 ExprValueKind VK, CastKind K, Expr *Op,
2104 Expr *LHS, Expr *RHS) {
2104 Expr *LHS, Expr *RHS) {
2109 Expr *PExp;
2124 ->isNullPointerConstant(Ctx, Expr::NPC_ValueDependentIsNotNull))
2174 const Expr *DefaultExpr) const {
2220 ArrayRef<Expr*> initExprs, SourceLocation rbraceloc)
2250 Expr *InitListExpr::updateInit(const ASTContext &C, unsigned Init, Expr *expr) {
2250 Expr *InitListExpr::updateInit(const ASTContext &C, unsigned Init, Expr *expr) {
2257 Expr *Result = cast_or_null<Expr>(InitExprs[Init]);
2257 Expr *Result = cast_or_null<Expr>(InitExprs[Init]);
2262 void InitListExpr::setArrayFiller(Expr *filler) {
2266 Expr **inits = getInits();
2279 const Expr *Init = getInit(0);
2383 bool Expr::isUnusedResultAWarning(const Expr *&WarnE, SourceLocation &Loc,
2650 if (const Expr *E = dyn_cast<Expr>(CS->body_back()))
2650 if (const Expr *E = dyn_cast<Expr>(CS->body_back()))
2653 if (const Expr *E = dyn_cast<Expr>(Label->getSubStmt()))
2653 if (const Expr *E = dyn_cast<Expr>(Label->getSubStmt()))
2738 const Expr *E = IgnoreParens();
2744 case Expr::UnaryOperatorClass:
2779 return ClassifyLValue(Ctx) == Expr::LV_MemberFunction;
2782 QualType Expr::findBoundMemberType(const Expr *expr) {
2806 static Expr *IgnoreImpCastsSingleStep(Expr *E) {
2806 static Expr *IgnoreImpCastsSingleStep(Expr *E) {
2816 static Expr *IgnoreImpCastsExtraSingleStep(Expr *E) {
2816 static Expr *IgnoreImpCastsExtraSingleStep(Expr *E) {
2820 Expr *SubE = IgnoreImpCastsSingleStep(E);
2833 static Expr *IgnoreCastsSingleStep(Expr *E) {
2833 static Expr *IgnoreCastsSingleStep(Expr *E) {
2849 static Expr *IgnoreLValueCastsSingleStep(Expr *E) {
2849 static Expr *IgnoreLValueCastsSingleStep(Expr *E) {
2859 static Expr *IgnoreBaseCastsSingleStep(Expr *E) {
2859 static Expr *IgnoreBaseCastsSingleStep(Expr *E) {
2869 static Expr *IgnoreImplicitSingleStep(Expr *E) {
2869 static Expr *IgnoreImplicitSingleStep(Expr *E) {
2870 Expr *SubE = IgnoreImpCastsSingleStep(E);
2883 static Expr *IgnoreParensSingleStep(Expr *E) {
2883 static Expr *IgnoreParensSingleStep(Expr *E) {
2908 static Expr *IgnoreNoopCastsSingleStep(const ASTContext &Ctx, Expr *E) {
2908 static Expr *IgnoreNoopCastsSingleStep(const ASTContext &Ctx, Expr *E) {
2912 Expr *SubExpr = CE->getSubExpr();
2931 static Expr *IgnoreExprNodesImpl(Expr *E) { return E; }
2931 static Expr *IgnoreExprNodesImpl(Expr *E) { return E; }
2933 static Expr *IgnoreExprNodesImpl(Expr *E, FnTy &&Fn, FnTys &&... Fns) {
2933 static Expr *IgnoreExprNodesImpl(Expr *E, FnTy &&Fn, FnTys &&... Fns) {
2941 static Expr *IgnoreExprNodes(Expr *E, FnTys &&... Fns) {
2941 static Expr *IgnoreExprNodes(Expr *E, FnTys &&... Fns) {
2942 Expr *LastE = nullptr;
2950 Expr *Expr::IgnoreImpCasts() {
2954 Expr *Expr::IgnoreCasts() {
2958 Expr *Expr::IgnoreImplicit() {
2962 Expr *Expr::IgnoreParens() {
2966 Expr *Expr::IgnoreParenImpCasts() {
2971 Expr *Expr::IgnoreParenCasts() {
2975 Expr *Expr::IgnoreConversionOperator() {
2983 Expr *Expr::IgnoreParenLValueCasts() {
2988 Expr *Expr::ignoreParenBaseCasts() {
2993 Expr *Expr::IgnoreParenNoopCasts(const ASTContext &Ctx) {
3000 const Expr *E = this;
3012 static const Expr *skipTemporaryBindingsNoOpCastsAndParens(const Expr *E) {
3012 static const Expr *skipTemporaryBindingsNoOpCastsAndParens(const Expr *E) {
3042 const Expr *E = skipTemporaryBindingsNoOpCastsAndParens(this);
3081 const Expr *E = this;
3124 bool Expr::hasAnyTypeDependentArguments(ArrayRef<Expr *> Exprs) {
3133 const Expr **Culprit) const {
3179 const Expr *Exp = cast<ConstantExpr>(this)->getSubExpr();
3186 const Expr *Exp = cast<CompoundLiteralExpr>(this)->getInitializer();
3219 const Expr *Elt = ILE->getInit(ElementNo++);
3315 const Expr* Arg = getArg(0);
3335 void VisitExpr(const Expr *E) {
3498 if (const Expr *E = cast<InitListExpr>(this)->getArrayFiller())
3517 if (const Expr *E = FD->getInClassInitializer())
3576 for (Expr *E : LE->capture_inits())
3589 const Expr *Subexpr = *I;
3618 cast<Expr>(SubStmt)->HasSideEffects(Ctx, IncludePossibleEffects))
3683 Expr::NullPointerConstantKind
3756 if (const Expr *Source = OVE->getSourceExpr())
3768 const Expr *InitExpr = CLE->getInitializer();
3804 const Expr *E = this;
3824 const Expr *E = IgnoreParenImpCasts();
3842 Expr *E = this->IgnoreParens();
3869 if (Expr *E = BD->getBinding())
3890 const Expr *E = this->IgnoreParens();
3908 if (auto *E = BD->getBinding())
3915 const Expr *E = this->IgnoreParenImpCasts();
3926 bool Expr::isSameComparisonOperand(const Expr* E1, const Expr* E2) {
3926 bool Expr::isSameComparisonOperand(const Expr* E1, const Expr* E2) {
4098 ShuffleVectorExpr::ShuffleVectorExpr(const ASTContext &C, ArrayRef<Expr*> args,
4122 void ShuffleVectorExpr::setExprs(const ASTContext &C, ArrayRef<Expr *> Exprs) {
4127 memcpy(SubExprs, Exprs.data(), sizeof(Expr *) * Exprs.size());
4131 const ASTContext &, SourceLocation GenericLoc, Expr *ControllingExpr,
4132 ArrayRef<TypeSourceInfo *> AssocTypes, ArrayRef<Expr *> AssocExprs,
4158 const ASTContext &Context, SourceLocation GenericLoc, Expr *ControllingExpr,
4159 ArrayRef<TypeSourceInfo *> AssocTypes, ArrayRef<Expr *> AssocExprs,
4185 const ASTContext &Context, SourceLocation GenericLoc, Expr *ControllingExpr,
4186 ArrayRef<TypeSourceInfo *> AssocTypes, ArrayRef<Expr *> AssocExprs,
4199 const ASTContext &Context, SourceLocation GenericLoc, Expr *ControllingExpr,
4200 ArrayRef<TypeSourceInfo *> AssocTypes, ArrayRef<Expr *> AssocExprs,
4237 ArrayRef<Expr*> IndexExprs,
4238 Expr *Init)
4260 Expr *Index = IndexExprs[IndexIdx];
4273 Expr *Start = IndexExprs[IndexIdx];
4274 Expr *End = IndexExprs[IndexIdx + 1];
4301 ArrayRef<Expr*> IndexExprs,
4303 bool UsesColonSyntax, Expr *Init) {
4354 Expr *DesignatedInitExpr::getArrayIndex(const Designator& D) const {
4359 Expr *DesignatedInitExpr::getArrayRangeStart(const Designator &D) const {
4365 Expr *DesignatedInitExpr::getArrayRangeEnd(const Designator &D) const {
4399 SourceLocation lBraceLoc, Expr *baseExpr, SourceLocation rBraceLoc)
4417 ParenListExpr::ParenListExpr(SourceLocation LParenLoc, ArrayRef<Expr *> Exprs,
4445 ArrayRef<Expr *> Exprs,
4459 const OpaqueValueExpr *OpaqueValueExpr::findInCopyConstruct(const Expr *e) {
4474 Context.Allocate(totalSizeToAlloc<Expr *>(1 + numSemanticExprs),
4484 PseudoObjectExpr *PseudoObjectExpr::Create(const ASTContext &C, Expr *syntax,
4485 ArrayRef<Expr*> semantics,
4502 void *buffer = C.Allocate(totalSizeToAlloc<Expr *>(semantics.size() + 1),
4509 Expr *syntax, ArrayRef<Expr*> semantics,
4509 Expr *syntax, ArrayRef<Expr*> semantics,
4517 Expr *E = (i == 0 ? syntax : semantics[i-1]);
4560 AtomicExpr::AtomicExpr(SourceLocation BLoc, ArrayRef<Expr*> args,
4649 QualType OMPArraySectionExpr::getBaseOriginalType(const Expr *Base) {
tools/clang/lib/AST/ExprCXX.cpp 64 const Expr *E = getSemanticForm()->IgnoreImplicit();
138 const Expr *E = getExprOperand();
169 ArrayRef<Expr *> PlacementArgs, SourceRange TypeIdParens,
170 Optional<Expr *> ArraySize,
172 Expr *Initializer, QualType Ty,
196 if (Expr *SizeExpr = *ArraySize) {
260 ArrayRef<Expr *> PlacementArgs, SourceRange TypeIdParens,
261 Optional<Expr *> ArraySize,
262 InitializationStyle InitializationStyle, Expr *Initializer,
301 const Expr *Arg = getArgument();
334 Expr *Base, bool isArrow, SourceLocation OperatorLoc,
601 const Expr *Arg = getArg(I-1);
615 Expr *Fn, ArrayRef<Expr *> Args,
615 Expr *Fn, ArrayRef<Expr *> Args,
636 const ASTContext &Ctx, OverloadedOperatorKind OpKind, Expr *Fn,
637 ArrayRef<Expr *> Args, QualType Ty, ExprValueKind VK,
684 CXXMemberCallExpr::CXXMemberCallExpr(Expr *Fn, ArrayRef<Expr *> Args,
684 CXXMemberCallExpr::CXXMemberCallExpr(Expr *Fn, ArrayRef<Expr *> Args,
693 CXXMemberCallExpr *CXXMemberCallExpr::Create(const ASTContext &Ctx, Expr *Fn,
694 ArrayRef<Expr *> Args, QualType Ty,
718 Expr *CXXMemberCallExpr::getImplicitObjectArgument() const {
719 const Expr *Callee = getCallee()->IgnoreParens();
746 Expr* ThisArg = getImplicitObjectArgument();
775 CastKind K, Expr *Op,
800 CastKind K, Expr *Op,
858 ExprValueKind VK, CastKind K, Expr *Op,
881 ExprValueKind VK, Expr *Op,
895 TypeSourceInfo *Written, CastKind K, Expr *Op,
922 UserDefinedLiteral::UserDefinedLiteral(Expr *Fn, ArrayRef<Expr *> Args,
922 UserDefinedLiteral::UserDefinedLiteral(Expr *Fn, ArrayRef<Expr *> Args,
933 UserDefinedLiteral *UserDefinedLiteral::Create(const ASTContext &Ctx, Expr *Fn,
934 ArrayRef<Expr *> Args,
980 Expr *UserDefinedLiteral::getCookedLiteral() {
1012 Expr* SubExpr) {
1022 ArrayRef<Expr *> Args, SourceRange ParenOrBraceRange,
1038 TypeSourceInfo *TSI, ArrayRef<Expr *> Args, SourceRange ParenOrBraceRange,
1072 CXXConstructorDecl *Ctor, bool Elidable, ArrayRef<Expr *> Args,
1096 bool Elidable, ArrayRef<Expr *> Args, bool HadMultipleCandidates,
1175 bool ExplicitResultType, ArrayRef<Expr *> CaptureInits,
1218 bool ExplicitParams, bool ExplicitResultType, ArrayRef<Expr *> CaptureInits,
1321 ExprWithCleanups::ExprWithCleanups(Expr *subexpr,
1331 ExprWithCleanups *ExprWithCleanups::Create(const ASTContext &C, Expr *subexpr,
1355 ArrayRef<Expr *> Args,
1369 auto **StoredArgs = getTrailingObjects<Expr *>();
1369 auto **StoredArgs = getTrailingObjects<Expr *>();
1380 ArrayRef<Expr *> Args, SourceLocation RParenLoc) {
1381 void *Mem = Context.Allocate(totalSizeToAlloc<Expr *>(Args.size()));
1388 void *Mem = Context.Allocate(totalSizeToAlloc<Expr *>(NumArgs));
1397 const ASTContext &Ctx, Expr *Base, QualType BaseType, bool IsArrow,
1446 const ASTContext &Ctx, Expr *Base, QualType BaseType, bool IsArrow,
1498 const ASTContext &Context, bool HasUnresolvedUsing, Expr *Base,
1534 return cast<Expr>(Base)->isImplicitCXXThis();
1538 const ASTContext &Context, bool HasUnresolvedUsing, Expr *Base,
1719 CUDAKernelCallExpr::CUDAKernelCallExpr(Expr *Fn, CallExpr *Config,
1720 ArrayRef<Expr *> Args, QualType Ty,
1731 CUDAKernelCallExpr::Create(const ASTContext &Ctx, Expr *Fn, CallExpr *Config,
1732 ArrayRef<Expr *> Args, QualType Ty, ExprValueKind VK,
tools/clang/lib/AST/ExprClassification.cpp 24 using Cl = Expr::Classification;
26 static Cl::Kinds ClassifyInternal(ASTContext &Ctx, const Expr *E);
32 const Expr *trueExpr,
33 const Expr *falseExpr);
34 static Cl::ModifiableType IsModifiable(ASTContext &Ctx, const Expr *E,
89 const Expr *E,
102 static Cl::Kinds ClassifyInternal(ASTContext &Ctx, const Expr *E) {
115 case Expr::ObjCIsaExprClass:
117 case Expr::StringLiteralClass:
119 case Expr::ObjCEncodeExprClass:
121 case Expr::PredefinedExprClass:
123 case Expr::ObjCSubscriptRefExprClass:
124 case Expr::ObjCPropertyRefExprClass:
126 case Expr::CXXTypeidExprClass:
129 case Expr::UnresolvedLookupExprClass:
130 case Expr::UnresolvedMemberExprClass:
131 case Expr::TypoExprClass:
132 case Expr::DependentCoawaitExprClass:
133 case Expr::CXXDependentScopeMemberExprClass:
134 case Expr::DependentScopeDeclRefExprClass:
137 case Expr::ObjCIvarRefExprClass:
138 case Expr::FunctionParmPackExprClass:
139 case Expr::MSPropertyRefExprClass:
140 case Expr::MSPropertySubscriptExprClass:
141 case Expr::OMPArraySectionExprClass:
146 case Expr::CompoundLiteralExprClass:
150 case Expr::CXXBoolLiteralExprClass:
151 case Expr::CXXPseudoDestructorExprClass:
152 case Expr::UnaryExprOrTypeTraitExprClass:
153 case Expr::CXXNewExprClass:
154 case Expr::CXXThisExprClass:
155 case Expr::CXXNullPtrLiteralExprClass:
156 case Expr::ImaginaryLiteralClass:
157 case Expr::GNUNullExprClass:
158 case Expr::OffsetOfExprClass:
159 case Expr::CXXThrowExprClass:
160 case Expr::ShuffleVectorExprClass:
161 case Expr::ConvertVectorExprClass:
162 case Expr::IntegerLiteralClass:
163 case Expr::FixedPointLiteralClass:
164 case Expr::CharacterLiteralClass:
165 case Expr::AddrLabelExprClass:
166 case Expr::CXXDeleteExprClass:
167 case Expr::ImplicitValueInitExprClass:
168 case Expr::BlockExprClass:
169 case Expr::FloatingLiteralClass:
170 case Expr::CXXNoexceptExprClass:
171 case Expr::CXXScalarValueInitExprClass:
172 case Expr::TypeTraitExprClass:
173 case Expr::ArrayTypeTraitExprClass:
174 case Expr::ExpressionTraitExprClass:
175 case Expr::ObjCSelectorExprClass:
176 case Expr::ObjCProtocolExprClass:
177 case Expr::ObjCStringLiteralClass:
178 case Expr::ObjCBoxedExprClass:
179 case Expr::ObjCArrayLiteralClass:
180 case Expr::ObjCDictionaryLiteralClass:
181 case Expr::ObjCBoolLiteralExprClass:
182 case Expr::ObjCAvailabilityCheckExprClass:
183 case Expr::ParenListExprClass:
184 case Expr::SizeOfPackExprClass:
185 case Expr::SubstNonTypeTemplateParmPackExprClass:
186 case Expr::AsTypeExprClass:
187 case Expr::ObjCIndirectCopyRestoreExprClass:
188 case Expr::AtomicExprClass:
189 case Expr::CXXFoldExprClass:
190 case Expr::ArrayInitLoopExprClass:
191 case Expr::ArrayInitIndexExprClass:
192 case Expr::NoInitExprClass:
193 case Expr::DesignatedInitUpdateExprClass:
194 case Expr::SourceLocExprClass:
195 case Expr::ConceptSpecializationExprClass:
198 case Expr::ConstantExprClass:
202 case Expr::SubstNonTypeTemplateParmExprClass:
210 case Expr::ArraySubscriptExprClass:
224 case Expr::DeclRefExprClass:
231 case Expr::MemberExprClass:
234 case Expr::UnaryOperatorClass:
250 const Expr *Op = cast<UnaryOperator>(E)->getSubExpr()->IgnoreParens();
270 case Expr::OpaqueValueExprClass:
274 case Expr::PseudoObjectExprClass:
280 case Expr::ImplicitCastExprClass:
285 case Expr::ParenExprClass:
291 case Expr::GenericSelectionExprClass:
296 case Expr::BinaryOperatorClass:
297 case Expr::CompoundAssignOperatorClass:
303 case Expr::CallExprClass:
304 case Expr::CXXOperatorCallExprClass:
305 case Expr::CXXMemberCallExprClass:
306 case Expr::UserDefinedLiteralClass:
307 case Expr::CUDAKernelCallExprClass:
310 case Expr::CXXRewrittenBinaryOperatorClass:
315 case Expr::ChooseExprClass:
320 case Expr::ExtVectorElementExprClass:
328 case Expr::CXXDefaultArgExprClass:
332 case Expr::CXXDefaultInitExprClass:
336 case Expr::CXXBindTemporaryExprClass:
340 case Expr::ExprWithCleanupsClass:
344 case Expr::CStyleCastExprClass:
345 case Expr::CXXFunctionalCastExprClass:
346 case Expr::CXXStaticCastExprClass:
347 case Expr::CXXDynamicCastExprClass:
348 case Expr::CXXReinterpretCastExprClass:
349 case Expr::CXXConstCastExprClass:
350 case Expr::ObjCBridgedCastExprClass:
351 case Expr::BuiltinBitCastExprClass:
356 case Expr::CXXUnresolvedConstructExprClass:
360 case Expr::BinaryConditionalOperatorClass: {
366 case Expr::ConditionalOperatorClass: {
375 case Expr::ObjCMessageExprClass:
384 case Expr::CXXConstructExprClass:
385 case Expr::CXXInheritedCtorInitExprClass:
386 case Expr::CXXTemporaryObjectExprClass:
387 case Expr::LambdaExprClass:
388 case Expr::CXXStdInitializerListExprClass:
391 case Expr::VAArgExprClass:
394 case Expr::DesignatedInitExprClass:
397 case Expr::StmtExprClass: {
399 if (const auto *LastExpr = dyn_cast_or_null<Expr>(S->body_back()))
399 if (const auto *LastExpr = dyn_cast_or_null<Expr>(S->body_back()))
404 case Expr::CXXUuidofExprClass:
407 case Expr::PackExpansionExprClass:
410 case Expr::MaterializeTemporaryExprClass:
415 case Expr::InitListExprClass:
426 case Expr::CoawaitExprClass:
427 case Expr::CoyieldExprClass:
494 Expr *Base = E->getBase()->IgnoreParens();
520 Expr *Base = E->getBase()->IgnoreParenImpCasts();
573 static Cl::Kinds ClassifyConditional(ASTContext &Ctx, const Expr *True,
574 const Expr *False) {
587 if (const Expr *NonThrow = TrueIsThrow ? (FalseIsThrow ? nullptr : False)
605 static Cl::ModifiableType IsModifiable(ASTContext &Ctx, const Expr *E,
658 Expr::LValueClassification Expr::ClassifyLValue(ASTContext &Ctx) const {
677 Expr::isModifiableLvalueResult
tools/clang/lib/AST/ExprConstant.cpp 102 const Expr *Base = B.get<const Expr*>();
102 const Expr *Base = B.get<const Expr*>();
108 SmallVector<const Expr *, 2> CommaLHSs;
110 const Expr *Temp = MTE->GetTemporaryExpr();
111 const Expr *Inner = Temp->skipRValueSubobjectAdjustments(CommaLHSs,
140 static QualType getStorageType(const ASTContext &Ctx, const Expr *E) {
156 static const CallExpr *tryUnwrapAllocSizeCall(const Expr *E) {
178 const auto *E = Base.dyn_cast<const Expr *>();
178 const auto *E = Base.dyn_cast<const Expr *>();
383 bool checkSubobject(EvalInfo &Info, const Expr *E, CheckSubobjectKind CSK);
440 void diagnoseUnsizedArrayPointerArithmetic(EvalInfo &Info, const Expr *E);
441 void diagnosePointerArithmetic(EvalInfo &Info, const Expr *E,
444 void adjustIndex(EvalInfo &Info, const Expr *E, APSInt N) {
623 static bool HandleDestruction(EvalInfo &Info, const Expr *E,
647 else if (const Expr *E = Base.dyn_cast<const Expr*>())
647 else if (const Expr *E = Base.dyn_cast<const Expr*>())
707 const Expr *AllocExpr = nullptr;
750 Expr::EvalStatus &EvalStatus;
921 EvalInfo(const ASTContext &C, Expr::EvalStatus &S, EvaluationMode Mode)
987 APValue *createHeapAlloc(const Expr *E, QualType T, LValue &LV);
1060 Expr::EvalStatus &getEvalStatus() const override { return EvalStatus; }
1236 Expr::EvalStatus OldStatus;
1337 bool SubobjectDesignator::checkSubobject(EvalInfo &Info, const Expr *E,
1354 const Expr *E) {
1361 const Expr *E,
1501 const auto *E = B.get<const Expr *>();
1501 const auto *E = B.get<const Expr *>();
1549 bool checkNullPointer(EvalInfo &Info, const Expr *E,
1556 bool checkNullPointerForFoldAccess(EvalInfo &Info, const Expr *E,
1565 bool checkSubobject(EvalInfo &Info, const Expr *E, CheckSubobjectKind CSK) {
1570 void addDecl(EvalInfo &Info, const Expr *E,
1575 void addUnsizedArray(EvalInfo &Info, const Expr *E, QualType ElemTy) {
1587 void addArray(EvalInfo &Info, const Expr *E, const ConstantArrayType *CAT) {
1591 void addComplex(EvalInfo &Info, const Expr *E, QualType EltTy, bool Imag) {
1598 void adjustOffsetAndIndex(EvalInfo &Info, const Expr *E,
1723 static bool Evaluate(APValue &Result, EvalInfo &Info, const Expr *E);
1725 const LValue &This, const Expr *E,
1727 static bool EvaluateLValue(const Expr *E, LValue &Result, EvalInfo &Info,
1729 static bool EvaluatePointer(const Expr *E, LValue &Result, EvalInfo &Info,
1731 static bool EvaluateMemberPointer(const Expr *E, MemberPtr &Result,
1733 static bool EvaluateTemporary(const Expr *E, LValue &Result, EvalInfo &Info);
1734 static bool EvaluateInteger(const Expr *E, APSInt &Result, EvalInfo &Info);
1735 static bool EvaluateIntegerOrLValue(const Expr *E, APValue &Result,
1737 static bool EvaluateFloat(const Expr *E, APFloat &Result, EvalInfo &Info);
1738 static bool EvaluateComplex(const Expr *E, ComplexValue &Res, EvalInfo &Info);
1739 static bool EvaluateAtomic(const Expr *E, const LValue *This, APValue &Result,
1741 static bool EvaluateAsRValue(EvalInfo &Info, const Expr *E, APValue &Result);
1744 static bool EvaluateFixedPointOrInteger(const Expr *E, APFixedPoint &Result,
1748 static bool EvaluateFixedPoint(const Expr *E, APFixedPoint &Result,
1766 APValue &CallStackFrame::createTemporary(const KeyT *Key, QualType T,
1787 APValue *EvalInfo::createHeapAlloc(const Expr *E, QualType T, LValue &LV) {
1841 static bool EvaluateIgnoredValue(EvalInfo &Info, const Expr *E) {
1875 const Expr *E = B.get<const Expr*>();
1875 const Expr *E = B.get<const Expr*>();
1879 case Expr::CompoundLiteralExprClass: {
1883 case Expr::MaterializeTemporaryExprClass:
1888 case Expr::StringLiteralClass:
1889 case Expr::PredefinedExprClass:
1890 case Expr::ObjCStringLiteralClass:
1891 case Expr::ObjCEncodeExprClass:
1892 case Expr::CXXUuidofExprClass:
1894 case Expr::ObjCBoxedExprClass:
1896 case Expr::CallExprClass:
1899 case Expr::AddrLabelExprClass:
1903 case Expr::BlockExprClass:
1905 case Expr::ImplicitValueInitExprClass:
1923 const Expr *E = Value.Base.dyn_cast<const Expr*>();
1923 const Expr *E = Value.Base.dyn_cast<const Expr*>();
1969 else if (const Expr *E = Base.dyn_cast<const Expr*>())
1969 else if (const Expr *E = Base.dyn_cast<const Expr*>())
1993 Expr::ConstExprUsage Usage,
2002 Expr::ConstExprUsage Usage,
2044 if (Usage == Expr::EvaluateForCodeGen && Var->hasAttr<DLLImportAttr>())
2059 if (Info.getLangOpts().CPlusPlus && Usage == Expr::EvaluateForCodeGen &&
2065 Base.dyn_cast<const Expr *>())) {
2113 Expr::ConstExprUsage Usage) {
2118 return Usage == Expr::EvaluateForMangling || FD->isVirtual() ||
2124 static bool CheckLiteralType(EvalInfo &Info, const Expr *E,
2157 Expr::ConstExprUsage Usage,
2241 Expr::ConstExprUsage Usage = Expr::EvaluateForCodeGen) {
2241 Expr::ConstExprUsage Usage = Expr::EvaluateForCodeGen) {
2255 Expr::EvaluateForCodeGen, SourceLocation(), CheckedTemps);
2325 static bool EvaluateAsBooleanCondition(const Expr *E, bool &Result,
2335 static bool HandleOverflow(EvalInfo &Info, const Expr *E,
2342 static bool HandleFloatToIntCast(EvalInfo &Info, const Expr *E,
2357 static bool HandleFloatToFloatCast(EvalInfo &Info, const Expr *E,
2367 static APSInt HandleIntToIntCast(EvalInfo &Info, const Expr *E,
2380 static bool HandleIntToFloatCast(EvalInfo &Info, const Expr *E,
2389 static bool truncateBitfieldValue(EvalInfo &Info, const Expr *E,
2410 static bool EvalAndBitcastToAPInt(EvalInfo &Info, const Expr *E,
2461 static bool CheckedIntArithmetic(EvalInfo &Info, const Expr *E,
2484 static bool handleIntIntBinOp(EvalInfo &Info, const Expr *E, const APSInt &LHS,
2586 static bool handleFloatFloatBinOp(EvalInfo &Info, const Expr *E,
2624 static bool CastToDerivedClass(EvalInfo &Info, const Expr *E, LValue &Result,
2653 static bool HandleLValueDirectBase(EvalInfo &Info, const Expr *E, LValue &Obj,
2667 static bool HandleLValueBase(EvalInfo &Info, const Expr *E, LValue &Obj,
2706 static bool CastToBaseClass(EvalInfo &Info, const Expr *E, LValue &Result,
2722 static bool HandleLValueMember(EvalInfo &Info, const Expr *E, LValue &LVal,
2737 static bool HandleLValueIndirectMember(EvalInfo &Info, const Expr *E,
2778 static bool HandleLValueArrayAdjustment(EvalInfo &Info, const Expr *E,
2789 static bool HandleLValueArrayAdjustment(EvalInfo &Info, const Expr *E,
2801 static bool HandleLValueComplexElement(EvalInfo &Info, const Expr *E,
2822 static bool evaluateVarDeclInit(EvalInfo &Info, const Expr *E,
2865 const Expr *Init = VD->getAnyInitializer(VD);
2929 static APSInt extractStringLiteralCharacter(EvalInfo &Info, const Expr *Lit,
3030 static bool diagnoseMutableFields(EvalInfo &Info, const Expr *E, AccessKinds AK,
3087 if (auto *BaseE = Base.dyn_cast<const Expr *>())
3157 findSubobject(EvalInfo &Info, const Expr *E, const CompleteObject &Obj,
3223 if (auto *E = Obj.Base.dyn_cast<const Expr *>())
3358 const Expr *E;
3382 static bool extractSubobject(EvalInfo &Info, const Expr *E,
3395 const Expr *E;
3440 static bool modifySubobject(EvalInfo &Info, const Expr *E,
3507 static CompleteObject findCompleteObject(EvalInfo &Info, const Expr *E,
3642 const Expr *Base = LVal.Base.dyn_cast<const Expr*>();
3642 const Expr *Base = LVal.Base.dyn_cast<const Expr*>();
3727 handleLValueToRValueConversion(EvalInfo &Info, const Expr *Conv, QualType Type,
3734 const Expr *Base = LVal.Base.dyn_cast<const Expr*>();
3734 const Expr *Base = LVal.Base.dyn_cast<const Expr*>();
3783 static bool handleAssignment(EvalInfo &Info, const Expr *E, const LValue &LVal,
3800 const Expr *E;
3907 EvalInfo &Info, const Expr *E,
4052 static bool handleIncDec(EvalInfo &Info, const Expr *E, const LValue &LVal,
4069 static bool EvaluateObjectArgument(EvalInfo &Info, const Expr *Object,
4098 const Expr *RHS,
4293 const Expr *InitE = VD->getInit();
4329 const Expr *Cond, bool &Result) {
4586 if (const Expr *E = dyn_cast<Expr>(S)) {
4586 if (const Expr *E = dyn_cast<Expr>(S)) {
4617 const Expr *RetExpr = cast<ReturnStmt>(S)->getRetValue();
4959 static bool checkDynamicType(EvalInfo &Info, const Expr *E, const LValue &This,
5001 checkNonVirtualMemberCallThisPointer(EvalInfo &Info, const Expr *E,
5026 static Optional<DynamicType> ComputeDynamicType(EvalInfo &Info, const Expr *E,
5081 EvalInfo &Info, const Expr *E, LValue &This, const CXXMethodDecl *Found,
5145 static bool HandleCovariantReturnAdjustment(EvalInfo &Info, const Expr *E,
5318 static bool HandleUnionActiveMemberChange(EvalInfo &Info, const Expr *LHSExpr,
5327 for (const Expr *E = LHSExpr; E != nullptr;) {
5432 static bool EvaluateArgs(ArrayRef<const Expr *> Args, ArgVector &ArgValues,
5474 ArrayRef<const Expr*> Args, const Stmt *Body,
5535 static bool HandleConstructorCall(const Expr *E, const LValue &This,
5699 const Expr *Init = I->getInit();
5733 static bool HandleConstructorCall(const Expr *E, const LValue &This,
5734 ArrayRef<const Expr*> Args,
5914 const Expr *E;
5937 static bool HandleDestruction(EvalInfo &Info, const Expr *E,
6041 static Optional<DynAlloc *> CheckDeleteKind(EvalInfo &Info, const Expr *E,
6614 bool DerivedSuccess(const APValue &V, const Expr *E) {
6617 bool DerivedZeroInitialization(const Expr *E) {
6664 Expr *EvalExpr = BoolResult ? E->getTrueExpr() : E->getFalseExpr();
6673 OptionalDiagnostic CCEDiag(const Expr *E, diag::kind D) {
6677 bool ZeroInitialization(const Expr *E) { return Error(E); }
6686 bool Error(const Expr *E, diag::kind D) {
6690 bool Error(const Expr *E) {
6697 bool VisitExpr(const Expr *E) {
6824 const Expr *Source = E->getSourceExpr();
6843 const Expr *Callee = E->getCallee()->IgnoreParens();
7132 const Expr *FinalExpr = dyn_cast<Expr>(*BI);
7132 const Expr *FinalExpr = dyn_cast<Expr>(*BI);
7159 void VisitIgnoredValue(const Expr *E) {
7164 void VisitIgnoredBaseExpression(const Expr *E) {
7193 bool evaluatePointer(const Expr *E, LValue &Result) {
7202 bool Success(const APValue &V, const Expr *E) {
7320 bool VisitVarDecl(const Expr *E, const VarDecl *VD);
7376 static bool EvaluateLValue(const Expr *E, LValue &Result, EvalInfo &Info,
7394 bool LValueExprEvaluator::VisitVarDecl(const Expr *E, const VarDecl *VD) {
7468 SmallVector<const Expr *, 2> CommaLHSs;
7470 const Expr *Inner = E->GetTemporaryExpr()->
7712 Expr::EvalResult ExprResult;
7713 if (!E->EvaluateAsInt(ExprResult, Ctx, Expr::SE_AllowSideEffects))
7752 const auto *Base = LVal.getLValueBase().get<const Expr *>();
7752 const auto *Base = LVal.getLValueBase().get<const Expr *>();
7776 const Expr *Init = VD->getAnyInitializer();
7780 const Expr *E = Init->IgnoreParens();
7799 bool Success(const Expr *E) {
7804 bool evaluateLValue(const Expr *E, LValue &Result) {
7808 bool evaluatePointer(const Expr *E, LValue &Result) {
7819 bool Success(const APValue &V, const Expr *E) {
7823 bool ZeroInitialization(const Expr *E) {
7899 static bool EvaluatePointer(const Expr* E, LValue& Result, EvalInfo &Info,
7910 const Expr *PExp = E->getLHS();
7911 const Expr *IExp = E->getRHS();
7935 const Expr *SubExpr = E->getSubExpr();
8091 static CharUnits GetAlignOfExpr(EvalInfo &Info, const Expr *E,
8169 } else if (const Expr *E = OffsetResult.Base.dyn_cast<const Expr *>()) {
8169 } else if (const Expr *E = OffsetResult.Base.dyn_cast<const Expr *>()) {
8512 const Expr *Init = E->getInitializer();
8516 if (Optional<const Expr*> ArraySize = E->getArraySize()) {
8517 const Expr *Stripped = *ArraySize;
8594 const Expr *E;
8676 bool Success(const APValue &V, const Expr *E) {
8680 bool ZeroInitialization(const Expr *E) {
8689 static bool EvaluateMemberPointer(const Expr *E, MemberPtr &Result,
8760 bool Success(const APValue &V, const Expr *E) {
8764 bool ZeroInitialization(const Expr *E) {
8767 bool ZeroInitialization(const Expr *E, QualType T);
8792 static bool HandleClassZeroInitialization(EvalInfo &Info, const Expr *E,
8835 bool RecordExprEvaluator::ZeroInitialization(const Expr *E, QualType T) {
8921 const Expr *InitExpr = E->getNumInits() ? E->getInit(0) : &VIE;
8944 const Expr *Init = E->getInit(ElementNo);
8982 const Expr *Init = HaveInit ? E->getInit(ElementNo++) : &VIE;
9138 Expr *const CurFieldInit = *CaptureInitIt++;
9156 static bool EvaluateRecord(const Expr *E, const LValue &This,
9178 bool VisitConstructExpr(const Expr *E) {
9212 static bool EvaluateTemporary(const Expr *E, LValue &Result, EvalInfo &Info) {
9230 bool Success(ArrayRef<APValue> V, const Expr *E) {
9236 bool Success(const APValue &V, const Expr *E) {
9241 bool ZeroInitialization(const Expr *E);
9254 static bool EvaluateVector(const Expr* E, APValue& Result, EvalInfo &Info) {
9263 const Expr *SE = E->getSubExpr();
9379 VectorExprEvaluator::ZeroInitialization(const Expr *E) {
9412 bool Success(const APValue &V, const Expr *E) {
9418 bool ZeroInitialization(const Expr *E) {
9453 static bool EvaluateArray(const Expr *E, const LValue &This,
9469 static bool MaybeElementDependentArrayFiller(const Expr *FillerExpr) {
9512 const Expr *FillerExpr = E->hasArrayFiller() ? E->getArrayFiller() : nullptr;
9536 const Expr *Init =
9651 bool Success(const llvm::APSInt &SI, const Expr *E, APValue &Result) {
9661 bool Success(const llvm::APSInt &SI, const Expr *E) {
9665 bool Success(const llvm::APInt &I, const Expr *E, APValue &Result) {
9675 bool Success(const llvm::APInt &I, const Expr *E) {
9679 bool Success(uint64_t Value, const Expr *E, APValue &Result) {
9685 bool Success(uint64_t Value, const Expr *E) {
9689 bool Success(CharUnits Size, const Expr *E) {
9693 bool Success(const APValue &V, const Expr *E) {
9701 bool ZeroInitialization(const Expr *E) { return Success(0, E); }
9716 bool CheckReferencedDecl(const Expr *E, const Decl *D);
9794 bool Success(const llvm::APInt &I, const Expr *E) {
9799 bool Success(uint64_t Value, const Expr *E) {
9804 bool Success(const APValue &V, const Expr *E) {
9808 bool Success(const APFixedPoint &V, const Expr *E) {
9838 static bool EvaluateIntegerOrLValue(const Expr *E, APValue &Result,
9844 static bool EvaluateInteger(const Expr *E, APSInt &Result, EvalInfo &Info) {
9864 static bool EvaluateFixedPoint(const Expr *E, APFixedPoint &Result,
9879 static bool EvaluateFixedPointOrInteger(const Expr *E, APFixedPoint &Result,
9897 bool IntExprEvaluator::CheckReferencedDecl(const Expr* E, const Decl* D) {
10111 } else if (const Expr *E = Base.dyn_cast<const Expr *>()) {
10111 } else if (const Expr *E = Base.dyn_cast<const Expr *>()) {
10127 static bool EvaluateBuiltinConstantP(EvalInfo &Info, const Expr *Arg) {
10180 } else if (const Expr *E = B.get<const Expr*>()) {
10180 } else if (const Expr *E = B.get<const Expr*>()) {
10198 static const Expr *ignorePointerCastsAndParens(const Expr *E) {
10198 static const Expr *ignorePointerCastsAndParens(const Expr *E) {
10247 if (auto *ME = dyn_cast_or_null<MemberExpr>(Base.dyn_cast<const Expr *>())) {
10320 const auto *E = LVal.Base.dyn_cast<const Expr *>();
10320 const auto *E = LVal.Base.dyn_cast<const Expr *>();
10444 static bool tryEvaluateBuiltinObjectSize(const Expr *E, unsigned Type,
10580 const Expr *Arg = E->getArg(0);
10715 String.getLValueBase().dyn_cast<const Expr *>())) {
10929 Expr::NPC_NeverValueDependent))
11119 const Expr *E;
11168 bool Success(uint64_t Value, const Expr *E, APValue &Result) {
11171 bool Success(const APSInt &Value, const Expr *E, APValue &Result) {
11174 bool Error(const Expr *E) {
11177 bool Error(const Expr *E, diag::kind D) {
11181 OptionalDiagnostic CCEDiag(const Expr *E, diag::kind D) {
11192 void EvaluateExpr(const Expr *E, EvalResult &Result) {
11200 void enqueue(const Expr *E) {
11331 const Expr *LHSExpr = LHSVal.getLValueBase().dyn_cast<const Expr*>();
11331 const Expr *LHSExpr = LHSVal.getLValueBase().dyn_cast<const Expr*>();
11332 const Expr *RHSExpr = RHSVal.getLValueBase().dyn_cast<const Expr*>();
11332 const Expr *RHSExpr = RHSVal.getLValueBase().dyn_cast<const Expr*>();
11827 const Expr *LHSExpr = LHSValue.Base.dyn_cast<const Expr *>();
11827 const Expr *LHSExpr = LHSValue.Base.dyn_cast<const Expr *>();
11828 const Expr *RHSExpr = RHSValue.Base.dyn_cast<const Expr *>();
11828 const Expr *RHSExpr = RHSValue.Base.dyn_cast<const Expr *>();
11961 const Expr *Idx = OOE->getIndexExpr(ON.getArrayExprIndex());
12062 const Expr *SubExpr = E->getSubExpr();
12299 const Expr *SubExpr = E->getSubExpr();
12339 const Expr *LHS = E->getLHS();
12340 const Expr *RHS = E->getRHS();
12379 bool Success(const APValue &V, const Expr *e) {
12384 bool ZeroInitialization(const Expr *E) {
12403 static bool EvaluateFloat(const Expr* E, APFloat& Result, EvalInfo &Info) {
12410 const Expr *Arg,
12572 const Expr* SubExpr = E->getSubExpr();
12615 bool Success(const APValue &V, const Expr *e) {
12620 bool ZeroInitialization(const Expr *E);
12634 static bool EvaluateComplex(const Expr *E, ComplexValue &Result,
12640 bool ComplexExprEvaluator::ZeroInitialization(const Expr *E) {
12657 const Expr* SubExpr = E->getSubExpr();
13113 bool Success(const APValue &V, const Expr *E) {
13118 bool ZeroInitialization(const Expr *E) {
13139 static bool EvaluateAtomic(const Expr *E, const LValue *This, APValue &Result,
13156 bool Success(const APValue &V, const Expr *e) { return true; }
13158 bool ZeroInitialization(const Expr *E) { return true; }
13203 const Expr *Arg = E->getArgument();
13264 static bool EvaluateVoid(const Expr *E, EvalInfo &Info) {
13273 static bool Evaluate(APValue &Result, EvalInfo &Info, const Expr *E) {
13356 const Expr *E, bool AllowNonLiteralTypes) {
13383 static bool EvaluateAsRValue(EvalInfo &Info, const Expr *E, APValue &Result) {
13417 static bool FastEvaluateAsRValue(const Expr *Exp, Expr::EvalResult &Result,
13417 static bool FastEvaluateAsRValue(const Expr *Exp, Expr::EvalResult &Result,
13446 static bool hasUnacceptableSideEffect(Expr::EvalStatus &Result,
13447 Expr::SideEffectsKind SEK) {
13448 return (SEK < Expr::SE_AllowSideEffects && Result.HasSideEffects) ||
13449 (SEK < Expr::SE_AllowUndefinedBehavior && Result.HasUndefinedBehavior);
13452 static bool EvaluateAsRValue(const Expr *E, Expr::EvalResult &Result,
13452 static bool EvaluateAsRValue(const Expr *E, Expr::EvalResult &Result,
13461 static bool EvaluateAsInt(const Expr *E, Expr::EvalResult &ExprResult,
13461 static bool EvaluateAsInt(const Expr *E, Expr::EvalResult &ExprResult,
13463 Expr::SideEffectsKind AllowSideEffects,
13476 static bool EvaluateAsFixedPoint(const Expr *E, Expr::EvalResult &ExprResult,
13476 static bool EvaluateAsFixedPoint(const Expr *E, Expr::EvalResult &ExprResult,
13478 Expr::SideEffectsKind AllowSideEffects,
13568 Expr::EvaluateForCodeGen, CheckedTemps))
13607 Expr::EvalStatus EStatus;
13670 Expr::EvalStatus EStatus;
13808 static ICEDiag CheckEvalInICE(const Expr* E, const ASTContext &Ctx) {
13809 Expr::EvalResult EVResult;
13810 Expr::EvalStatus Status;
13821 static ICEDiag CheckICE(const Expr* E, const ASTContext &Ctx) {
13831 case Expr::PredefinedExprClass:
13832 case Expr::FloatingLiteralClass:
13833 case Expr::ImaginaryLiteralClass:
13834 case Expr::StringLiteralClass:
13835 case Expr::ArraySubscriptExprClass:
13836 case Expr::OMPArraySectionExprClass:
13837 case Expr::MemberExprClass:
13838 case Expr::CompoundAssignOperatorClass:
13839 case Expr::CompoundLiteralExprClass:
13840 case Expr::ExtVectorElementExprClass:
13841 case Expr::DesignatedInitExprClass:
13842 case Expr::ArrayInitLoopExprClass:
13843 case Expr::ArrayInitIndexExprClass:
13844 case Expr::NoInitExprClass:
13845 case Expr::DesignatedInitUpdateExprClass:
13846 case Expr::ImplicitValueInitExprClass:
13847 case Expr::ParenListExprClass:
13848 case Expr::VAArgExprClass:
13849 case Expr::AddrLabelExprClass:
13850 case Expr::StmtExprClass:
13851 case Expr::CXXMemberCallExprClass:
13852 case Expr::CUDAKernelCallExprClass:
13853 case Expr::CXXDynamicCastExprClass:
13854 case Expr::CXXTypeidExprClass:
13855 case Expr::CXXUuidofExprClass:
13856 case Expr::MSPropertyRefExprClass:
13857 case Expr::MSPropertySubscriptExprClass:
13858 case Expr::CXXNullPtrLiteralExprClass:
13859 case Expr::UserDefinedLiteralClass:
13860 case Expr::CXXThisExprClass:
13861 case Expr::CXXThrowExprClass:
13862 case Expr::CXXNewExprClass:
13863 case Expr::CXXDeleteExprClass:
13864 case Expr::CXXPseudoDestructorExprClass:
13865 case Expr::UnresolvedLookupExprClass:
13866 case Expr::TypoExprClass:
13867 case Expr::DependentScopeDeclRefExprClass:
13868 case Expr::CXXConstructExprClass:
13869 case Expr::CXXInheritedCtorInitExprClass:
13870 case Expr::CXXStdInitializerListExprClass:
13871 case Expr::CXXBindTemporaryExprClass:
13872 case Expr::ExprWithCleanupsClass:
13873 case Expr::CXXTemporaryObjectExprClass:
13874 case Expr::CXXUnresolvedConstructExprClass:
13875 case Expr::CXXDependentScopeMemberExprClass:
13876 case Expr::UnresolvedMemberExprClass:
13877 case Expr::ObjCStringLiteralClass:
13878 case Expr::ObjCBoxedExprClass:
13879 case Expr::ObjCArrayLiteralClass:
13880 case Expr::ObjCDictionaryLiteralClass:
13881 case Expr::ObjCEncodeExprClass:
13882 case Expr::ObjCMessageExprClass:
13883 case Expr::ObjCSelectorExprClass:
13884 case Expr::ObjCProtocolExprClass:
13885 case Expr::ObjCIvarRefExprClass:
13886 case Expr::ObjCPropertyRefExprClass:
13887 case Expr::ObjCSubscriptRefExprClass:
13888 case Expr::ObjCIsaExprClass:
13889 case Expr::ObjCAvailabilityCheckExprClass:
13890 case Expr::ShuffleVectorExprClass:
13891 case Expr::ConvertVectorExprClass:
13892 case Expr::BlockExprClass:
13893 case Expr::NoStmtClass:
13894 case Expr::OpaqueValueExprClass:
13895 case Expr::PackExpansionExprClass:
13896 case Expr::SubstNonTypeTemplateParmPackExprClass:
13897 case Expr::FunctionParmPackExprClass:
13898 case Expr::AsTypeExprClass:
13899 case Expr::ObjCIndirectCopyRestoreExprClass:
13900 case Expr::MaterializeTemporaryExprClass:
13901 case Expr::PseudoObjectExprClass:
13902 case Expr::AtomicExprClass:
13903 case Expr::LambdaExprClass:
13904 case Expr::CXXFoldExprClass:
13905 case Expr::CoawaitExprClass:
13906 case Expr::DependentCoawaitExprClass:
13907 case Expr::CoyieldExprClass:
13910 case Expr::InitListExprClass: {
13921 case Expr::SizeOfPackExprClass:
13922 case Expr::GNUNullExprClass:
13923 case Expr::SourceLocExprClass:
13926 case Expr::SubstNonTypeTemplateParmExprClass:
13930 case Expr::ConstantExprClass:
13933 case Expr::ParenExprClass:
13935 case Expr::GenericSelectionExprClass:
13937 case Expr::IntegerLiteralClass:
13938 case Expr::FixedPointLiteralClass:
13939 case Expr::CharacterLiteralClass:
13940 case Expr::ObjCBoolLiteralExprClass:
13941 case Expr::CXXBoolLiteralExprClass:
13942 case Expr::CXXScalarValueInitExprClass:
13943 case Expr::TypeTraitExprClass:
13944 case Expr::ConceptSpecializationExprClass:
13945 case Expr::ArrayTypeTraitExprClass:
13946 case Expr::ExpressionTraitExprClass:
13947 case Expr::CXXNoexceptExprClass:
13949 case Expr::CallExprClass:
13950 case Expr::CXXOperatorCallExprClass: {
13959 case Expr::CXXRewrittenBinaryOperatorClass:
13962 case Expr::DeclRefExprClass: {
13992 case Expr::UnaryOperatorClass: {
14017 case Expr::OffsetOfExprClass: {
14026 case Expr::UnaryExprOrTypeTraitExprClass: {
14033 case Expr::BinaryOperatorClass: {
14121 case Expr::ImplicitCastExprClass:
14122 case Expr::CStyleCastExprClass:
14123 case Expr::CXXFunctionalCastExprClass:
14124 case Expr::CXXStaticCastExprClass:
14125 case Expr::CXXReinterpretCastExprClass:
14126 case Expr::CXXConstCastExprClass:
14127 case Expr::ObjCBridgedCastExprClass: {
14128 const Expr *SubExpr = cast<CastExpr>(E)->getSubExpr();
14158 case Expr::BinaryConditionalOperatorClass: {
14169 case Expr::ConditionalOperatorClass: {
14201 case Expr::CXXDefaultArgExprClass:
14203 case Expr::CXXDefaultInitExprClass:
14205 case Expr::ChooseExprClass: {
14208 case Expr::BuiltinBitCastExprClass: {
14220 const Expr *E,
14273 Expr::EvalStatus Status;
14301 Expr::EvalStatus Status;
14326 ArrayRef<const Expr*> Args,
14327 const Expr *This) const {
14331 Expr::EvalStatus Status;
14350 for (ArrayRef<const Expr*>::iterator I = Args.begin(), E = Args.end();
14376 Expr::EvalStatus Status;
14404 ArrayRef<const Expr*> Args;
14421 bool Expr::isPotentialConstantExprUnevaluated(Expr *E,
14428 Expr::EvalStatus Status;
14437 ArrayRef<const Expr*> Args;
14455 Expr::EvalStatus Status;
tools/clang/lib/AST/ExprObjC.cpp 26 ObjCArrayLiteral::ObjCArrayLiteral(ArrayRef<Expr *> Elements, QualType T,
31 Expr **SaveElements = getElements();
45 ArrayRef<Expr *> Elements,
48 void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(Elements.size()));
54 void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(NumElements));
128 ObjCMethodDecl *Method, ArrayRef<Expr *> Args,
149 ObjCMethodDecl *Method, ArrayRef<Expr *> Args,
163 SourceLocation LBracLoc, Expr *Receiver,
166 ObjCMethodDecl *Method, ArrayRef<Expr *> Args,
180 void ObjCMessageExpr::initArgsAndSelLocs(ArrayRef<Expr *> Args,
184 Expr **MyArgs = getArgs();
210 ObjCMethodDecl *Method, ArrayRef<Expr *> Args,
229 ObjCMethodDecl *Method, ArrayRef<Expr *> Args,
246 SourceLocation LBracLoc, Expr *Receiver, Selector Sel,
248 ObjCMethodDecl *Method, ArrayRef<Expr *> Args,
271 ArrayRef<Expr *> Args,
tools/clang/lib/AST/Interp/ByteCodeEmitter.h 54 virtual bool visitExpr(const Expr *E) = 0;
tools/clang/lib/AST/Interp/ByteCodeExprGen.cpp 147 const Expr *LHS = BO->getLHS();
148 const Expr *RHS = BO->getRHS();
209 bool ByteCodeExprGen<Emitter>::discard(const Expr *E) {
215 bool ByteCodeExprGen<Emitter>::visit(const Expr *E) {
221 bool ByteCodeExprGen<Emitter>::visitBool(const Expr *E) {
230 bool ByteCodeExprGen<Emitter>::visitZeroInitializer(PrimType T, const Expr *E) {
258 const Expr *LV, DerefKind AK, llvm::function_ref<bool(PrimType)> Direct,
283 const Expr *LV, PrimType T, const ParmVarDecl *PD, DerefKind AK,
325 const Expr *LV, PrimType T, const VarDecl *VD, DerefKind AK,
395 const APInt &Value, const Expr *E) {
427 Descriptor *D = P.createDescriptor(Src, Ty, IsConst, Src.is<const Expr *>());
446 if (auto *E = Src.dyn_cast<const Expr *>()) {
465 const Expr *Init, InitFnRef InitFn) {
471 bool ByteCodeExprGen<Emitter>::getPtrVarDecl(const VarDecl *VD, const Expr *E) {
519 bool ByteCodeExprGen<Emitter>::visitExpr(const Expr *Exp) {
532 const Expr *Init = VD->getInit();
tools/clang/lib/AST/Interp/ByteCodeExprGen.h 75 bool visitExpr(const Expr *E) override;
102 llvm::Optional<PrimType> classify(const Expr *E) const {
123 bool discard(const Expr *E);
125 bool visit(const Expr *E);
127 bool visitInitializer(const Expr *E, InitFnRef GenPtr);
130 bool visitBool(const Expr *E);
133 bool visitLocalInitializer(const Expr *Init, unsigned I) {
140 bool visitGlobalInitializer(const Expr *Init, unsigned I) {
147 bool visitThisInitializer(const Expr *I) {
167 bool visitZeroInitializer(PrimType T, const Expr *E);
181 bool dereference(const Expr *LV, DerefKind AK,
184 bool dereferenceParam(const Expr *LV, PrimType T, const ParmVarDecl *PD,
188 bool dereferenceVar(const Expr *LV, PrimType T, const VarDecl *PD,
194 const Expr *E);
197 template <typename T> bool emitConst(const Expr *E, T Value) {
205 bool getPtrVarDecl(const VarDecl *VD, const Expr *E);
tools/clang/lib/AST/Interp/ByteCodeStmtGen.cpp 128 if (auto *Exp = dyn_cast<Expr>(S))
166 if (const Expr *RE = RS->getRetValue()) {
tools/clang/lib/AST/Interp/Context.cpp 54 InterpResult Context::evaluateAsRValue(State &Parent, const Expr *E,
tools/clang/lib/AST/Interp/Context.h 61 InterpResult evaluateAsRValue(State &Parent, const Expr *E, APValue &Result);
tools/clang/lib/AST/Interp/Descriptor.cpp 256 if (auto *E = Source.dyn_cast<const Expr *>())
tools/clang/lib/AST/Interp/Descriptor.h 26 using DeclTy = llvm::PointerUnion<const Decl *, const Expr *>;
113 const Expr *asExpr() const { return Source.dyn_cast<const Expr *>(); }
113 const Expr *asExpr() const { return Source.dyn_cast<const Expr *>(); }
tools/clang/lib/AST/Interp/EvalEmitter.cpp 29 llvm::Expected<bool> EvalEmitter::interpretExpr(const Expr *E) {
tools/clang/lib/AST/Interp/EvalEmitter.h 42 llvm::Expected<bool> interpretExpr(const Expr *E);
57 virtual bool visitExpr(const Expr *E) = 0;
tools/clang/lib/AST/Interp/Interp.h 118 const Expr *E = S.Current->getExpr(OpPC);
853 const Expr *E = S.Current->getExpr(OpPC);
881 const Expr *E = S.Current->getExpr(OpPC);
tools/clang/lib/AST/Interp/InterpFrame.cpp 186 const Expr *InterpFrame::getExpr(CodePtr PC) const {
tools/clang/lib/AST/Interp/InterpFrame.h 110 const Expr *getExpr(CodePtr PC) const;
tools/clang/lib/AST/Interp/InterpState.cpp 51 bool InterpState::reportOverflow(const Expr *E, const llvm::APSInt &Value) {
tools/clang/lib/AST/Interp/InterpState.h 50 Expr::EvalStatus &getEvalStatus() const override {
78 bool reportOverflow(const Expr *E, const llvm::APSInt &Value);
tools/clang/lib/AST/Interp/Program.cpp 158 llvm::Optional<unsigned> Program::createGlobal(const Expr *E) {
167 const bool IsTemporary = D.dyn_cast<const Expr *>();
tools/clang/lib/AST/Interp/Program.h 72 llvm::Optional<unsigned> createGlobal(const Expr *E);
tools/clang/lib/AST/Interp/Source.cpp 16 if (const Expr *E = asExpr())
25 const Expr *SourceInfo::asExpr() const {
27 return dyn_cast<Expr>(S);
31 const Expr *SourceMapper::getExpr(Function *F, CodePtr PC) const {
32 if (const Expr *E = getSource(F, PC).asExpr())
tools/clang/lib/AST/Interp/Source.h 91 const Expr *asExpr() const;
110 const Expr *getExpr(Function *F, CodePtr PC) const;
tools/clang/lib/AST/Interp/State.cpp 25 OptionalDiagnostic State::FFDiag(const Expr *E, diag::kind DiagId,
52 OptionalDiagnostic State::CCEDiag(const Expr *E, diag::kind DiagId,
88 Expr::EvalStatus &EvalStatus = getEvalStatus();
tools/clang/lib/AST/Interp/State.h 68 virtual Expr::EvalStatus &getEvalStatus() const = 0;
81 FFDiag(const Expr *E,
101 CCEDiag(const Expr *E,
tools/clang/lib/AST/ItaniumMangle.cpp 534 void mangleMemberExprBase(const Expr *base, bool isArrow);
535 void mangleMemberExpr(const Expr *base, bool isArrow,
542 void mangleCastExpression(const Expr *E, StringRef CastEncoding);
545 void mangleExpression(const Expr *E, unsigned Arity = UnknownArity);
3379 Expr *E = T->getUnderlyingExpr();
3468 void CXXNameMangler::mangleMemberExprBase(const Expr *Base, bool IsArrow) {
3492 void CXXNameMangler::mangleMemberExpr(const Expr *base,
3511 const Expr *callee = call->getCallee();
3512 const Expr *fn = callee->IgnoreParens();
3538 void CXXNameMangler::mangleCastExpression(const Expr *E, StringRef CastEncoding) {
3578 void CXXNameMangler::mangleExpression(const Expr *E, unsigned Arity) {
3606 case Expr::NoStmtClass:
3616 case Expr::AddrLabelExprClass:
3617 case Expr::DesignatedInitUpdateExprClass:
3618 case Expr::ImplicitValueInitExprClass:
3619 case Expr::ArrayInitLoopExprClass:
3620 case Expr::ArrayInitIndexExprClass:
3621 case Expr::NoInitExprClass:
3622 case Expr::ParenListExprClass:
3623 case Expr::LambdaExprClass:
3624 case Expr::MSPropertyRefExprClass:
3625 case Expr::MSPropertySubscriptExprClass:
3626 case Expr::TypoExprClass: // This should no longer exist in the AST by now.
3627 case Expr::OMPArraySectionExprClass:
3628 case Expr::CXXInheritedCtorInitExprClass:
3631 case Expr::ConstantExprClass:
3636 case Expr::BlockExprClass:
3637 case Expr::ChooseExprClass:
3638 case Expr::CompoundLiteralExprClass:
3639 case Expr::ExtVectorElementExprClass:
3640 case Expr::GenericSelectionExprClass:
3641 case Expr::ObjCEncodeExprClass:
3642 case Expr::ObjCIsaExprClass:
3643 case Expr::ObjCIvarRefExprClass:
3644 case Expr::ObjCMessageExprClass:
3645 case Expr::ObjCPropertyRefExprClass:
3646 case Expr::ObjCProtocolExprClass:
3647 case Expr::ObjCSelectorExprClass:
3648 case Expr::ObjCStringLiteralClass:
3649 case Expr::ObjCBoxedExprClass:
3650 case Expr::ObjCArrayLiteralClass:
3651 case Expr::ObjCDictionaryLiteralClass:
3652 case Expr::ObjCSubscriptRefExprClass:
3653 case Expr::ObjCIndirectCopyRestoreExprClass:
3654 case Expr::ObjCAvailabilityCheckExprClass:
3655 case Expr::OffsetOfExprClass:
3656 case Expr::PredefinedExprClass:
3657 case Expr::ShuffleVectorExprClass:
3658 case Expr::ConvertVectorExprClass:
3659 case Expr::StmtExprClass:
3660 case Expr::TypeTraitExprClass:
3661 case Expr::ArrayTypeTraitExprClass:
3662 case Expr::ExpressionTraitExprClass:
3663 case Expr::VAArgExprClass:
3664 case Expr::CUDAKernelCallExprClass:
3665 case Expr::AsTypeExprClass:
3666 case Expr::PseudoObjectExprClass:
3667 case Expr::AtomicExprClass:
3668 case Expr::SourceLocExprClass:
3669 case Expr::FixedPointLiteralClass:
3670 case Expr::BuiltinBitCastExprClass:
3683 case Expr::CXXUuidofExprClass: {
3690 Expr *UuidExp = UE->getExprOperand();
3698 case Expr::BinaryConditionalOperatorClass: {
3709 case Expr::OpaqueValueExprClass:
3712 case Expr::InitListExprClass: {
3719 case Expr::DesignatedInitExprClass: {
3740 case Expr::CXXDefaultArgExprClass:
3744 case Expr::CXXDefaultInitExprClass:
3748 case Expr::CXXStdInitializerListExprClass:
3752 case Expr::SubstNonTypeTemplateParmExprClass:
3757 case Expr::UserDefinedLiteralClass:
3760 case Expr::CXXMemberCallExprClass: // fallthrough
3761 case Expr::CallExprClass: {
3780 for (const Expr *Arg : CE->arguments())
3785 for (const Expr *Arg : CE->arguments())
3791 case Expr::CXXNewExprClass: {
3805 const Expr *Init = New->getInitializer();
3826 case Expr::CXXPseudoDestructorExprClass: {
3828 if (const Expr *Base = PDE->getBase())
3852 case Expr::MemberExprClass: {
3862 case Expr::UnresolvedMemberExprClass: {
3872 case Expr::CXXDependentScopeMemberExprClass: {
3884 case Expr::UnresolvedLookupExprClass: {
3892 case Expr::CXXUnresolvedConstructExprClass: {
3914 case Expr::CXXConstructExprClass: {
3930 case Expr::CXXTemporaryObjectExprClass: {
3959 case Expr::CXXScalarValueInitExprClass:
3965 case Expr::CXXNoexceptExprClass:
3970 case Expr::UnaryExprOrTypeTraitExprClass: {
4024 case Expr::CXXThrowExprClass: {
4037 case Expr::CXXTypeidExprClass: {
4051 case Expr::CXXDeleteExprClass: {
4061 case Expr::UnaryOperatorClass: {
4069 case Expr::ArraySubscriptExprClass: {
4080 case Expr::CompoundAssignOperatorClass: // fallthrough
4081 case Expr::BinaryOperatorClass: {
4093 case Expr::CXXRewrittenBinaryOperatorClass: {
4104 case Expr::ConditionalOperatorClass: {
4113 case Expr::ImplicitCastExprClass: {
4119 case Expr::ObjCBridgedCastExprClass: {
4128 case Expr::CStyleCastExprClass:
4132 case Expr::CXXFunctionalCastExprClass: {
4151 case Expr::CXXStaticCastExprClass:
4154 case Expr::CXXDynamicCastExprClass:
4157 case Expr::CXXReinterpretCastExprClass:
4160 case Expr::CXXConstCastExprClass:
4164 case Expr::CXXOperatorCallExprClass: {
4177 case Expr::ParenExprClass:
4182 case Expr::ConceptSpecializationExprClass: {
4193 case Expr::DeclRefExprClass:
4197 case Expr::SubstNonTypeTemplateParmPackExprClass:
4205 case Expr::FunctionParmPackExprClass: {
4213 case Expr::DependentScopeDeclRefExprClass: {
4221 case Expr::CXXBindTemporaryExprClass:
4225 case Expr::ExprWithCleanupsClass:
4229 case Expr::FloatingLiteralClass: {
4238 case Expr::CharacterLiteralClass:
4246 case Expr::ObjCBoolLiteralExprClass:
4252 case Expr::CXXBoolLiteralExprClass:
4258 case Expr::IntegerLiteralClass: {
4266 case Expr::ImaginaryLiteralClass: {
4289 case Expr::StringLiteralClass: {
4298 case Expr::GNUNullExprClass:
4305 case Expr::CXXNullPtrLiteralExprClass: {
4310 case Expr::PackExpansionExprClass:
4315 case Expr::SizeOfPackExprClass: {
4340 case Expr::MaterializeTemporaryExprClass: {
4345 case Expr::CXXFoldExprClass: {
4366 case Expr::CXXThisExprClass:
4370 case Expr::CoawaitExprClass:
4376 case Expr::DependentCoawaitExprClass:
4382 case Expr::CoyieldExprClass:
4562 const Expr *E = A.getAsExpr()->IgnoreParenImpCasts();
tools/clang/lib/AST/JSONNodeDumper.cpp 54 if (const auto *E = dyn_cast<Expr>(S)) {
54 if (const auto *E = dyn_cast<Expr>(S)) {
tools/clang/lib/AST/MicrosoftMangle.cpp 379 void mangleExpression(const Expr *E);
1361 void MicrosoftCXXNameMangler::mangleExpression(const Expr *E) {
tools/clang/lib/AST/NSAPI.cpp 575 bool NSAPI::isObjCEnumerator(const Expr *E,
tools/clang/lib/AST/OSLog.cpp 22 const Expr *E = nullptr;
25 Optional<const Expr *> Count;
26 Optional<const Expr *> Precision;
27 Optional<const Expr *> FieldWidth;
32 ArrayRef<const Expr *> Args;
54 OSLogFormatStringHandler(ArrayRef<const Expr *> Args) : Args(Args) {
182 ArrayRef<const Expr *> Args(E->getArgs(), E->getArgs() + E->getNumArgs());
184 const Expr *StringArg;
185 ArrayRef<const Expr *> VarArgs;
tools/clang/lib/AST/OpenMPClause.cpp 265 OMPOrderedClause *OMPOrderedClause::Create(const ASTContext &C, Expr *Num,
270 void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(2 * NumLoops));
282 void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(2 * NumLoops));
292 Expr *NumIterations) {
294 getTrailingObjects<Expr *>()[NumLoop] = NumIterations;
297 ArrayRef<Expr *> OMPOrderedClause::getLoopNumIterations() const {
298 return llvm::makeArrayRef(getTrailingObjects<Expr *>(), NumberOfLoops);
301 void OMPOrderedClause::setLoopCounter(unsigned NumLoop, Expr *Counter) {
303 getTrailingObjects<Expr *>()[NumberOfLoops + NumLoop] = Counter;
306 Expr *OMPOrderedClause::getLoopCounter(unsigned NumLoop) {
308 return getTrailingObjects<Expr *>()[NumberOfLoops + NumLoop];
311 const Expr *OMPOrderedClause::getLoopCounter(unsigned NumLoop) const {
313 return getTrailingObjects<Expr *>()[NumberOfLoops + NumLoop];
316 void OMPPrivateClause::setPrivateCopies(ArrayRef<Expr *> VL) {
325 ArrayRef<Expr *> VL, ArrayRef<Expr *> PrivateVL) {
325 ArrayRef<Expr *> VL, ArrayRef<Expr *> PrivateVL) {
327 void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(2 * VL.size()));
337 void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(2 * N));
341 void OMPFirstprivateClause::setPrivateCopies(ArrayRef<Expr *> VL) {
347 void OMPFirstprivateClause::setInits(ArrayRef<Expr *> VL) {
356 ArrayRef<Expr *> VL, ArrayRef<Expr *> PrivateVL,
356 ArrayRef<Expr *> VL, ArrayRef<Expr *> PrivateVL,
357 ArrayRef<Expr *> InitVL, Stmt *PreInit) {
358 void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(3 * VL.size()));
370 void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(3 * N));
374 void OMPLastprivateClause::setPrivateCopies(ArrayRef<Expr *> PrivateCopies) {
380 void OMPLastprivateClause::setSourceExprs(ArrayRef<Expr *> SrcExprs) {
387 void OMPLastprivateClause::setDestinationExprs(ArrayRef<Expr *> DstExprs) {
394 void OMPLastprivateClause::setAssignmentOps(ArrayRef<Expr *> AssignmentOps) {
404 SourceLocation EndLoc, ArrayRef<Expr *> VL, ArrayRef<Expr *> SrcExprs,
404 SourceLocation EndLoc, ArrayRef<Expr *> VL, ArrayRef<Expr *> SrcExprs,
405 ArrayRef<Expr *> DstExprs, ArrayRef<Expr *> AssignmentOps, Stmt *PreInit,
405 ArrayRef<Expr *> DstExprs, ArrayRef<Expr *> AssignmentOps, Stmt *PreInit,
406 Expr *PostUpdate) {
407 void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(5 * VL.size()));
421 void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(5 * N));
429 ArrayRef<Expr *> VL) {
430 void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(VL.size()));
438 void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(N));
442 void OMPLinearClause::setPrivates(ArrayRef<Expr *> PL) {
448 void OMPLinearClause::setInits(ArrayRef<Expr *> IL) {
454 void OMPLinearClause::setUpdates(ArrayRef<Expr *> UL) {
460 void OMPLinearClause::setFinals(ArrayRef<Expr *> FL) {
466 void OMPLinearClause::setUsedExprs(ArrayRef<Expr *> UE) {
476 SourceLocation ColonLoc, SourceLocation EndLoc, ArrayRef<Expr *> VL,
477 ArrayRef<Expr *> PL, ArrayRef<Expr *> IL, Expr *Step, Expr *CalcStep,
477 ArrayRef<Expr *> PL, ArrayRef<Expr *> IL, Expr *Step, Expr *CalcStep,
477 ArrayRef<Expr *> PL, ArrayRef<Expr *> IL, Expr *Step, Expr *CalcStep,
477 ArrayRef<Expr *> PL, ArrayRef<Expr *> IL, Expr *Step, Expr *CalcStep,
478 Stmt *PreInit, Expr *PostUpdate) {
482 C.Allocate(totalSizeToAlloc<Expr *>(5 * VL.size() + 2 + VL.size() + 1));
507 void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(5 * NumVars + 2 + NumVars +1));
521 SourceLocation EndLoc, ArrayRef<Expr *> VL, Expr *A) {
521 SourceLocation EndLoc, ArrayRef<Expr *> VL, Expr *A) {
522 void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(VL.size() + 1));
532 void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(NumVars + 1));
536 void OMPCopyinClause::setSourceExprs(ArrayRef<Expr *> SrcExprs) {
543 void OMPCopyinClause::setDestinationExprs(ArrayRef<Expr *> DstExprs) {
550 void OMPCopyinClause::setAssignmentOps(ArrayRef<Expr *> AssignmentOps) {
560 SourceLocation EndLoc, ArrayRef<Expr *> VL, ArrayRef<Expr *> SrcExprs,
560 SourceLocation EndLoc, ArrayRef<Expr *> VL, ArrayRef<Expr *> SrcExprs,
561 ArrayRef<Expr *> DstExprs, ArrayRef<Expr *> AssignmentOps) {
561 ArrayRef<Expr *> DstExprs, ArrayRef<Expr *> AssignmentOps) {
562 void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(4 * VL.size()));
573 void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(4 * N));
577 void OMPCopyprivateClause::setSourceExprs(ArrayRef<Expr *> SrcExprs) {
584 void OMPCopyprivateClause::setDestinationExprs(ArrayRef<Expr *> DstExprs) {
591 void OMPCopyprivateClause::setAssignmentOps(ArrayRef<Expr *> AssignmentOps) {
601 SourceLocation EndLoc, ArrayRef<Expr *> VL, ArrayRef<Expr *> SrcExprs,
601 SourceLocation EndLoc, ArrayRef<Expr *> VL, ArrayRef<Expr *> SrcExprs,
602 ArrayRef<Expr *> DstExprs, ArrayRef<Expr *> AssignmentOps) {
602 ArrayRef<Expr *> DstExprs, ArrayRef<Expr *> AssignmentOps) {
603 void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(4 * VL.size()));
615 void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(4 * N));
619 void OMPReductionClause::setPrivates(ArrayRef<Expr *> Privates) {
625 void OMPReductionClause::setLHSExprs(ArrayRef<Expr *> LHSExprs) {
632 void OMPReductionClause::setRHSExprs(ArrayRef<Expr *> RHSExprs) {
639 void OMPReductionClause::setReductionOps(ArrayRef<Expr *> ReductionOps) {
648 SourceLocation EndLoc, SourceLocation ColonLoc, ArrayRef<Expr *> VL,
650 ArrayRef<Expr *> Privates, ArrayRef<Expr *> LHSExprs,
650 ArrayRef<Expr *> Privates, ArrayRef<Expr *> LHSExprs,
651 ArrayRef<Expr *> RHSExprs, ArrayRef<Expr *> ReductionOps, Stmt *PreInit,
651 ArrayRef<Expr *> RHSExprs, ArrayRef<Expr *> ReductionOps, Stmt *PreInit,
652 Expr *PostUpdate) {
653 void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(5 * VL.size()));
668 void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(5 * N));
672 void OMPTaskReductionClause::setPrivates(ArrayRef<Expr *> Privates) {
678 void OMPTaskReductionClause::setLHSExprs(ArrayRef<Expr *> LHSExprs) {
685 void OMPTaskReductionClause::setRHSExprs(ArrayRef<Expr *> RHSExprs) {
692 void OMPTaskReductionClause::setReductionOps(ArrayRef<Expr *> ReductionOps) {
701 SourceLocation EndLoc, SourceLocation ColonLoc, ArrayRef<Expr *> VL,
703 ArrayRef<Expr *> Privates, ArrayRef<Expr *> LHSExprs,
703 ArrayRef<Expr *> Privates, ArrayRef<Expr *> LHSExprs,
704 ArrayRef<Expr *> RHSExprs, ArrayRef<Expr *> ReductionOps, Stmt *PreInit,
704 ArrayRef<Expr *> RHSExprs, ArrayRef<Expr *> ReductionOps, Stmt *PreInit,
705 Expr *PostUpdate) {
706 void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(5 * VL.size()));
721 void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(5 * N));
725 void OMPInReductionClause::setPrivates(ArrayRef<Expr *> Privates) {
731 void OMPInReductionClause::setLHSExprs(ArrayRef<Expr *> LHSExprs) {
738 void OMPInReductionClause::setRHSExprs(ArrayRef<Expr *> RHSExprs) {
745 void OMPInReductionClause::setReductionOps(ArrayRef<Expr *> ReductionOps) {
753 ArrayRef<Expr *> TaskgroupDescriptors) {
763 SourceLocation EndLoc, SourceLocation ColonLoc, ArrayRef<Expr *> VL,
765 ArrayRef<Expr *> Privates, ArrayRef<Expr *> LHSExprs,
765 ArrayRef<Expr *> Privates, ArrayRef<Expr *> LHSExprs,
766 ArrayRef<Expr *> RHSExprs, ArrayRef<Expr *> ReductionOps,
766 ArrayRef<Expr *> RHSExprs, ArrayRef<Expr *> ReductionOps,
767 ArrayRef<Expr *> TaskgroupDescriptors, Stmt *PreInit, Expr *PostUpdate) {
767 ArrayRef<Expr *> TaskgroupDescriptors, Stmt *PreInit, Expr *PostUpdate) {
768 void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(6 * VL.size()));
784 void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(6 * N));
790 SourceLocation LParenLoc, Expr *Allocator,
792 ArrayRef<Expr *> VL) {
794 void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(VL.size()));
803 void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(N));
811 ArrayRef<Expr *> VL) {
812 void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(VL.size() + 1));
820 void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(N));
828 SourceLocation ColonLoc, ArrayRef<Expr *> VL,
830 void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(VL.size() + NumLoops));
844 void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(N + NumLoops));
848 void OMPDependClause::setLoopData(unsigned NumLoop, Expr *Cnt) {
858 Expr *OMPDependClause::getLoopData(unsigned NumLoop) {
868 const Expr *OMPDependClause::getLoopData(unsigned NumLoop) const {
901 const ASTContext &C, const OMPVarListLocTy &Locs, ArrayRef<Expr *> Vars,
903 MappableExprComponentListsRef ComponentLists, ArrayRef<Expr *> UDMapperRefs,
925 totalSizeToAlloc<Expr *, ValueDecl *, unsigned,
946 totalSizeToAlloc<Expr *, ValueDecl *, unsigned,
955 const ASTContext &C, const OMPVarListLocTy &Locs, ArrayRef<Expr *> Vars,
957 MappableExprComponentListsRef ComponentLists, ArrayRef<Expr *> UDMapperRefs,
976 totalSizeToAlloc<Expr *, ValueDecl *, unsigned,
993 totalSizeToAlloc<Expr *, ValueDecl *, unsigned,
1002 const ASTContext &C, const OMPVarListLocTy &Locs, ArrayRef<Expr *> Vars,
1004 MappableExprComponentListsRef ComponentLists, ArrayRef<Expr *> UDMapperRefs,
1023 totalSizeToAlloc<Expr *, ValueDecl *, unsigned,
1042 totalSizeToAlloc<Expr *, ValueDecl *, unsigned,
1050 void OMPUseDevicePtrClause::setPrivateCopies(ArrayRef<Expr *> VL) {
1056 void OMPUseDevicePtrClause::setInits(ArrayRef<Expr *> VL) {
1063 const ASTContext &C, const OMPVarListLocTy &Locs, ArrayRef<Expr *> Vars,
1064 ArrayRef<Expr *> PrivateVars, ArrayRef<Expr *> Inits,
1064 ArrayRef<Expr *> PrivateVars, ArrayRef<Expr *> Inits,
1084 totalSizeToAlloc<Expr *, ValueDecl *, unsigned,
1103 totalSizeToAlloc<Expr *, ValueDecl *, unsigned,
1113 ArrayRef<Expr *> Vars,
1133 totalSizeToAlloc<Expr *, ValueDecl *, unsigned,
1150 totalSizeToAlloc<Expr *, ValueDecl *, unsigned,
1257 if (auto *E = Node->getChunkSize()) {
1266 if (auto *Num = Node->getNumForLoops()) {
1374 if (Expr *Allocator = Node->getAllocator()) {
1618 if (auto *E = Node->getChunkSize()) {
tools/clang/lib/AST/ParentMap.cpp 157 } while (S && isa<Expr>(S) && cast<Expr>(S)->IgnoreParenImpCasts() != S);
157 } while (S && isa<Expr>(S) && cast<Expr>(S)->IgnoreParenImpCasts() != S);
171 bool ParentMap::isConsumedExpr(Expr* E) const {
187 return isa<Expr>(P);
tools/clang/lib/AST/SelectorLocationsKind.cpp 50 SourceLocation getArgLoc<Expr>(Expr *Arg) {
50 SourceLocation getArgLoc<Expr>(Expr *Arg) {
64 SourceLocation getArgLoc(unsigned Index, ArrayRef<T*> Args) {
71 ArrayRef<T *> Args,
98 ArrayRef<Expr *> Args,
106 ArrayRef<Expr *> Args,
tools/clang/lib/AST/Stmt.cpp 334 const Expr *ValueStmt::getExprStmt() const {
337 if (const auto *E = dyn_cast<Expr>(S))
337 if (const auto *E = dyn_cast<Expr>(S))
388 const Expr *AsmStmt::getOutputExpr(unsigned i) const {
404 const Expr *AsmStmt::getInputExpr(unsigned i) const {
439 Expr *GCCAsmStmt::getOutputExpr(unsigned i) {
440 return cast<Expr>(Exprs[i]);
450 Expr *GCCAsmStmt::getInputExpr(unsigned i) {
451 return cast<Expr>(Exprs[i + NumOutputs]);
454 void GCCAsmStmt::setInputExpr(unsigned i, Expr *E) {
737 Expr *MSAsmStmt::getOutputExpr(unsigned i) {
738 return cast<Expr>(Exprs[i]);
741 Expr *MSAsmStmt::getInputExpr(unsigned i) {
742 return cast<Expr>(Exprs[i + NumOutputs]);
745 void MSAsmStmt::setInputExpr(unsigned i, Expr *E) {
756 StringLiteral **constraints, Expr **exprs,
783 ArrayRef<StringRef> constraints, ArrayRef<Expr*> exprs,
799 ArrayRef<Expr*> exprs,
830 Stmt *Init, VarDecl *Var, Expr *Cond, Stmt *Then,
864 bool IsConstexpr, Stmt *Init, VarDecl *Var, Expr *Cond,
911 ForStmt::ForStmt(const ASTContext &C, Stmt *Init, Expr *Cond, VarDecl *condVar,
912 Expr *Inc, Stmt *Body, SourceLocation FL, SourceLocation LP,
944 Expr *Cond)
970 Expr *Cond) {
1008 WhileStmt::WhileStmt(const ASTContext &Ctx, VarDecl *Var, Expr *Cond,
1027 WhileStmt *WhileStmt::Create(const ASTContext &Ctx, VarDecl *Var, Expr *Cond,
1072 ReturnStmt::ReturnStmt(SourceLocation RL, Expr *E, const VarDecl *NRVOCandidate)
1087 Expr *E, const VarDecl *NRVOCandidate) {
1102 CaseStmt *CaseStmt::Create(const ASTContext &Ctx, Expr *lhs, Expr *rhs,
1102 CaseStmt *CaseStmt::Create(const ASTContext &Ctx, Expr *lhs, Expr *rhs,
1143 SEHExceptStmt::SEHExceptStmt(SourceLocation Loc, Expr *FilterExpr, Stmt *Block)
1150 Expr *FilterExpr, Stmt *Block) {
1213 ArrayRef<Expr *> CaptureInits,
1244 ArrayRef<Expr *> CaptureInits,
tools/clang/lib/AST/StmtCXX.cpp 49 Expr *Cond, Expr *Inc, DeclStmt *LoopVar,
49 Expr *Cond, Expr *Inc, DeclStmt *LoopVar,
65 Expr *CXXForRangeStmt::getRangeInit() {
72 const Expr *CXXForRangeStmt::getRangeInit() const {
tools/clang/lib/AST/StmtObjC.cpp 20 ObjCForCollectionStmt::ObjCForCollectionStmt(Stmt *Elem, Expr *Collect,
tools/clang/lib/AST/StmtOpenMP.cpp 44 void OMPLoopDirective::setCounters(ArrayRef<Expr *> A) {
50 void OMPLoopDirective::setPrivateCounters(ArrayRef<Expr *> A) {
57 void OMPLoopDirective::setInits(ArrayRef<Expr *> A) {
63 void OMPLoopDirective::setUpdates(ArrayRef<Expr *> A) {
69 void OMPLoopDirective::setFinals(ArrayRef<Expr *> A) {
75 void OMPLoopDirective::setDependentCounters(ArrayRef<Expr *> A) {
82 void OMPLoopDirective::setDependentInits(ArrayRef<Expr *> A) {
88 void OMPLoopDirective::setFinalsConditions(ArrayRef<Expr *> A) {
579 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, Expr *ReductionRef) {
583 void *Mem = C.Allocate(Size + sizeof(Stmt *) + sizeof(Expr *));
598 void *Mem = C.Allocate(Size + sizeof(Stmt *) + sizeof(Expr *));
697 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, Expr *X, Expr *V,
697 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, Expr *X, Expr *V,
698 Expr *E, Expr *UE, bool IsXLHSInRHSPart, bool IsPostfixUpdate) {
698 Expr *E, Expr *UE, bool IsXLHSInRHSPart, bool IsPostfixUpdate) {
tools/clang/lib/AST/StmtPrinter.cpp 89 if (S && isa<Expr>(S)) {
108 PrintExpr(cast<Expr>(S));
135 void PrintExpr(Expr *E) {
158 void VisitExpr(Expr *Node) LLVM_ATTRIBUTE_UNUSED {
343 PrintExpr(cast<Expr>(Node->getElement()));
984 static bool isImplicitSelf(const Expr *E) {
1101 static bool printExprAsWritten(raw_ostream &OS, Expr *E,
1353 static bool isImplicitThis(const Expr *E) {
2029 if (Optional<Expr *> Size = E->getArraySize()) {
tools/clang/lib/AST/StmtProfile.cpp 500 if (auto *Num = C->getNumForLoops())
724 if (Expr *Allocator = C->getAllocator())
859 if (const Expr *E = S->getReductionRef())
1029 void StmtProfiler::VisitExpr(const Expr *S) {
tools/clang/lib/AST/TextNodeDumper.cpp 127 if (const auto *E = dyn_cast<Expr>(Node)) {
127 if (const auto *E = dyn_cast<Expr>(Node)) {
1454 if (const auto *Initializer = D->getInitializer()) {
tools/clang/lib/AST/Type.cpp 118 ArraySizeModifier sm, unsigned tq, const Expr *sz)
189 const Expr *SizeExpr, ArraySizeModifier SizeMod,
202 Expr *e, ArraySizeModifier sm,
213 Expr *E) {
222 Expr *SizeExpr, SourceLocation Loc, VectorType::VectorKind VecKind)
234 QualType ElementType, const Expr *SizeExpr,
245 Expr *SizeExpr,
258 QualType ElementType, Expr *SizeExpr) {
265 Expr *AddrSpaceExpr, SourceLocation loc)
278 Expr *AddrSpaceExpr) {
3017 *getTrailingObjects<Expr *>() = epi.ExceptionSpec.NoexceptExpr;
3071 if (Expr *NE = getNoexceptExpr())
3083 if (Expr *NE = getNoexceptExpr())
3208 TypeOfExprType::TypeOfExprType(Expr *E, QualType can)
3227 const ASTContext &Context, Expr *E) {
3231 DecltypeType::DecltypeType(Expr *E, QualType underlyingType, QualType can)
3250 DependentDecltypeType::DependentDecltypeType(const ASTContext &Context, Expr *E)
3254 const ASTContext &Context, Expr *E) {
tools/clang/lib/ASTMatchers/ASTMatchFinder.cpp 148 if (Expr *ExprNode = dyn_cast_or_null<Expr>(StmtNode))
148 if (Expr *ExprNode = dyn_cast_or_null<Expr>(StmtNode))
tools/clang/lib/ASTMatchers/ASTMatchersInternal.cpp 689 const internal::VariadicDynCastAllOfMatcher<Stmt, Expr> expr;
tools/clang/lib/ASTMatchers/Dynamic/Marshallers.h 75 return Value.isMatcher() && Value.getMatcher().hasTypedMatcher<T>();
78 static ast_matchers::internal::Matcher<T> get(const VariantValue &Value) {
79 return Value.getMatcher().getTypedMatcher<T>();
83 return ArgKind(ast_type_traits::ASTNodeKind::getFromNodeKind<T>());
361 RetTypes.push_back(ast_type_traits::ASTNodeKind::getFromNodeKind<T>());
466 ast_matchers::internal::VariadicDynCastAllOfMatcher<BaseT, DerivedT> Func,
469 DerivedKind(ast_type_traits::ASTNodeKind::getFromNodeKind<DerivedT>()) {
778 ast_matchers::internal::VariadicDynCastAllOfMatcher<BaseT, DerivedT>
tools/clang/lib/Analysis/AnalysisDeclContext.cpp 184 if (const auto *e = dyn_cast<Expr>(stmt))
184 if (const auto *e = dyn_cast<Expr>(stmt))
192 if (const auto *e = dyn_cast<Expr>(stmt))
192 if (const auto *e = dyn_cast<Expr>(stmt))
617 Expr *Semantic = *it;
tools/clang/lib/Analysis/BodyFarm.cpp 54 BinaryOperator *makeAssignment(const Expr *LHS, const Expr *RHS, QualType Ty);
54 BinaryOperator *makeAssignment(const Expr *LHS, const Expr *RHS, QualType Ty);
57 BinaryOperator *makeComparison(const Expr *LHS, const Expr *RHS,
57 BinaryOperator *makeComparison(const Expr *LHS, const Expr *RHS,
68 UnaryOperator *makeDereference(const Expr *Arg, QualType Ty);
71 Expr *makeIntegralCast(const Expr *Arg, QualType Ty);
71 Expr *makeIntegralCast(const Expr *Arg, QualType Ty);
74 ImplicitCastExpr *makeIntegralCastToBoolean(const Expr *Arg);
77 ImplicitCastExpr *makeLvalueToRvalue(const Expr *Arg, QualType Ty);
86 ImplicitCastExpr *makeImplicitCast(const Expr *Arg, QualType Ty,
93 ObjCIvarRefExpr *makeObjCIvarRef(const Expr *Base, const ObjCIvarDecl *IVar);
96 ReturnStmt *makeReturn(const Expr *RetVal);
102 MemberExpr *makeMemberExpression(Expr *base, ValueDecl *MemberDecl,
115 BinaryOperator *ASTMaker::makeAssignment(const Expr *LHS, const Expr *RHS,
115 BinaryOperator *ASTMaker::makeAssignment(const Expr *LHS, const Expr *RHS,
122 BinaryOperator *ASTMaker::makeComparison(const Expr *LHS, const Expr *RHS,
122 BinaryOperator *ASTMaker::makeComparison(const Expr *LHS, const Expr *RHS,
149 UnaryOperator *ASTMaker::makeDereference(const Expr *Arg, QualType Ty) {
155 ImplicitCastExpr *ASTMaker::makeLvalueToRvalue(const Expr *Arg, QualType Ty) {
168 ImplicitCastExpr *ASTMaker::makeImplicitCast(const Expr *Arg, QualType Ty,
177 Expr *ASTMaker::makeIntegralCast(const Expr *Arg, QualType Ty) {
177 Expr *ASTMaker::makeIntegralCast(const Expr *Arg, QualType Ty) {
185 ImplicitCastExpr *ASTMaker::makeIntegralCastToBoolean(const Expr *Arg) {
195 ObjCIvarRefExpr *ASTMaker::makeObjCIvarRef(const Expr *Base,
203 ReturnStmt *ASTMaker::makeReturn(const Expr *RetVal) {
213 MemberExpr *ASTMaker::makeMemberExpression(Expr *base, ValueDecl *MemberDecl,
251 ArrayRef<Expr *> CallArgs) {
255 Expr *SubExpr;
278 ArrayRef<Expr *> CallArgs) {
377 SmallVector<Expr *, 5> CallArgs;
421 Expr *ParamExpr = M.makeDeclRefExpr(PDecl);
520 Expr *DoneValue =
548 Expr *GuardCondition = M.makeComparison(LValToRval, DoneValue, BO_NE);
625 Expr *Comparison =
645 Expr *BoolVal = M.makeObjCBool(true);
646 Expr *RetVal = isBoolean ? M.makeIntegralCastToBoolean(BoolVal)
787 Expr *loadedIVar =
tools/clang/lib/Analysis/CFG.cpp 68 if (Expr *Ex = VD->getInit())
75 static bool IsIntegerLiteralConstantExpr(const Expr *E) {
99 static const Expr *tryTransformToIntOrEnumConstant(const Expr *E) {
99 static const Expr *tryTransformToIntOrEnumConstant(const Expr *E) {
113 static std::tuple<const Expr *, BinaryOperatorKind, const Expr *>
113 static std::tuple<const Expr *, BinaryOperatorKind, const Expr *>
117 const Expr *MaybeDecl = B->getLHS();
118 const Expr *Constant = tryTransformToIntOrEnumConstant(B->getRHS());
144 static bool areExprTypesCompatible(const Expr *E1, const Expr *E2) {
144 static bool areExprTypesCompatible(const Expr *E1, const Expr *E2) {
510 llvm::DenseMap<Expr *, const ConstructionContextLayer *>
521 Expr::EvalResult *switchCond = nullptr;
528 using CachedBoolEvalsTy = llvm::DenseMap<Expr *, TryResult>;
616 CFGBlock *VisitNoRecurse(Expr *E, AddStmtChoice asc);
708 Expr *E);
728 Expr *Arg = E->getArg(i);
740 void cleanupConstructionContext(Expr *E);
775 const ConstructionContext *retrieveAndCleanupConstructionContext(Expr *E) {
922 const Expr *LHSExpr = B->getLHS()->IgnoreParens();
923 const Expr *RHSExpr = B->getRHS()->IgnoreParens();
926 const Expr *BoolExpr = RHSExpr;
961 const Expr *LHSExpr = B->getLHS()->IgnoreParens();
962 const Expr *RHSExpr = B->getRHS()->IgnoreParens();
965 const Expr *BoolExpr = RHSExpr;
978 const Expr *LHSExpr2 = BitOp->getLHS()->IgnoreParens();
979 const Expr *RHSExpr2 = BitOp->getRHS()->IgnoreParens();
1047 const Expr *DeclExpr1;
1048 const Expr *NumExpr1;
1055 const Expr *DeclExpr2;
1056 const Expr *NumExpr2;
1064 if (!Expr::isSameComparisonOperand(DeclExpr1, DeclExpr2))
1072 Expr::EvalResult L1Result, L2Result;
1144 const Expr *LHSConstant =
1146 const Expr *RHSConstant =
1152 const Expr *Constant = LHSConstant ? LHSConstant : RHSConstant;
1154 Expr::EvalResult Result;
1168 bool tryEvaluate(Expr *S, Expr::EvalResult &outResult) {
1168 bool tryEvaluate(Expr *S, Expr::EvalResult &outResult) {
1178 TryResult tryEvaluateBool(Expr *S) {
1204 Expr::EvalResult LHSResult;
1211 Expr::EvalResult RHSResult;
1228 TryResult evaluateAsBooleanConditionNoCache(Expr *E) {
1342 const ConstructionContextLayer *Layer, Expr *E) {
1390 auto *E = cast<Expr>(Child);
1390 auto *E = cast<Expr>(Child);
1465 void CFGBuilder::cleanupConstructionContext(Expr *E) {
1636 Expr *Init = I->getInit();
1682 static QualType getReferenceInitTemporaryType(const Expr *Init,
1704 SmallVector<const Expr *, 2> CommaLHSs;
1706 const Expr *SkippedInit =
1986 const Expr *Init = VD->getInit();
2127 if (Expr *E = dyn_cast<Expr>(S))
2127 if (Expr *E = dyn_cast<Expr>(S))
2397 Expr *RHS = B->getRHS()->IgnoreParens();
2440 Expr *LHS = B->getLHS()->IgnoreParens();
2520 CFGBlock *CFGBuilder::VisitNoRecurse(Expr *E, AddStmtChoice asc) {
2549 static bool CanThrow(Expr *E, ASTContext &Ctx) {
2568 QualType boundType = Expr::findBoundMemberType(C->getCallee());
2730 const Expr *trueExpr = C->getTrueExpr();
2760 Expr *condExpr = C->getCond();
2838 Expr *Init = VD->getInit();
3065 if (Expr *O = RS->getRetValue())
3216 if (Expr *CopyExpr = CI.getCopyExpr()) {
3229 if (Expr *Init = *it) {
3380 Expr *C = F->getCond();
3410 if (Expr *Init = VD->getInit()) {
3632 Expr *Semantic = E->getSemanticExpr(--i);
3716 Expr *C = W->getCond();
3740 if (Expr *Init = VD->getInit()) {
4046 Expr::EvalResult result;
4048 SaveAndRestore<Expr::EvalResult*> save_switchCond(switchCond,
4083 if (Expr *Init = VD->getInit()) {
4101 const Expr::EvalResult *switchCond,
4120 if (const Expr *RHS = CS->getRHS()) {
4374 if (Expr *C = S->getCond()) {
4647 SmallVector<const Expr *, 2> CommaLHSs;
4655 for (const Expr *CommaLHS : CommaLHSs) {
4672 for (Expr *Init : LE->capture_inits()) {
4971 if (const Expr *Init = var->getInit()) {
5275 void VisitExpr(Expr *E) {
5307 if (Expr *IE = I->getInit())
5463 if (isa<Expr>(S))
5871 const Expr *CFGBlock::getLastCondition() const {
5892 return cast<Expr>(Cond)->IgnoreParens();
5900 Expr *E = nullptr;
tools/clang/lib/Analysis/CallGraph.cpp 60 Expr *CEE = CE->getCallee()->IgnoreParenImpCasts();
tools/clang/lib/Analysis/ConstructionContext.cpp 145 const auto *E = cast<Expr>(ParentItem.getStmt());
145 const auto *E = cast<Expr>(ParentItem.getStmt());
210 const auto *E = cast<Expr>(TopItem.getStmt());
210 const auto *E = cast<Expr>(TopItem.getStmt());
tools/clang/lib/Analysis/Consumed.cpp 476 ConstInfoEntry findInfo(const Expr *E) const {
483 void insertInfo(const Expr *E, const PropagationInfo &PI) {
487 void forwardInfo(const Expr *From, const Expr *To);
487 void forwardInfo(const Expr *From, const Expr *To);
488 void copyInfo(const Expr *From, const Expr *To, ConsumedState CS);
488 void copyInfo(const Expr *From, const Expr *To, ConsumedState CS);
489 ConsumedState getInfo(const Expr *From);
490 void setInfo(const Expr *To, ConsumedState NS);
491 void propagateReturnType(const Expr *Call, const FunctionDecl *Fun);
497 bool handleCall(const CallExpr *Call, const Expr *ObjArg,
519 PropagationInfo getInfo(const Expr *StmtNode) const {
536 void ConsumedStmtVisitor::forwardInfo(const Expr *From, const Expr *To) {
536 void ConsumedStmtVisitor::forwardInfo(const Expr *From, const Expr *To) {
544 void ConsumedStmtVisitor::copyInfo(const Expr *From, const Expr *To,
544 void ConsumedStmtVisitor::copyInfo(const Expr *From, const Expr *To,
558 ConsumedState ConsumedStmtVisitor::getInfo(const Expr *From) {
568 void ConsumedStmtVisitor::setInfo(const Expr *To, ConsumedState NS) {
611 bool ConsumedStmtVisitor::handleCall(const CallExpr *Call, const Expr *ObjArg,
684 void ConsumedStmtVisitor::propagateReturnType(const Expr *Call,
1236 const Expr *Cond = IfNode->getCond();
tools/clang/lib/Analysis/ExprMutationAnalyzer.cpp 29 const Expr* Result = &Node;
87 const StringRef ID = NodeID<T>::value;
89 if (const Stmt *S = (Analyzer->*Finder)(Nodes.getNodeAs<T>(ID)))
97 const Stmt *ExprMutationAnalyzer::findMutation(const Expr *Exp) {
113 const Stmt *ExprMutationAnalyzer::findPointeeMutation(const Expr *Exp) {
122 const Expr *Exp, llvm::ArrayRef<MutationFinder> Finders,
142 match(findAll(declRefExpr(to(equalsNode(Dec))).bind(NodeID<Expr>::value)),
145 const auto *E = RefNodes.getNodeAs<Expr>(NodeID<Expr>::value);
145 const auto *E = RefNodes.getNodeAs<Expr>(NodeID<Expr>::value);
145 const auto *E = RefNodes.getNodeAs<Expr>(NodeID<Expr>::value);
152 bool ExprMutationAnalyzer::isUnevaluated(const Expr *Exp) {
153 return selectFirst<Expr>(
154 NodeID<Expr>::value,
179 .bind(NodeID<Expr>::value)),
185 return tryEachMatch<Expr>(Matches, this, &ExprMutationAnalyzer::findMutation);
195 return tryEachMatch<Expr>(Matches, this,
205 const Stmt *ExprMutationAnalyzer::findDirectMutation(const Expr *Exp) {
296 const Stmt *ExprMutationAnalyzer::findMemberMutation(const Expr *Exp) {
302 .bind(NodeID<Expr>::value)),
307 const Stmt *ExprMutationAnalyzer::findArrayElementMutation(const Expr *Exp) {
311 .bind(NodeID<Expr>::value)),
316 const Stmt *ExprMutationAnalyzer::findCastMutation(const Expr *Exp) {
324 .bind(NodeID<Expr>::value)),
338 const Stmt *ExprMutationAnalyzer::findRangeLoopMutation(const Expr *Exp) {
350 const Stmt *ExprMutationAnalyzer::findReferenceMutation(const Expr *Exp) {
360 .bind(NodeID<Expr>::value)),
384 const Stmt *ExprMutationAnalyzer::findFunctionArgMutation(const Expr *Exp) {
396 .bind(NodeID<Expr>::value)),
399 const auto *Exp = Nodes.getNodeAs<Expr>(NodeID<Expr>::value);
399 const auto *Exp = Nodes.getNodeAs<Expr>(NodeID<Expr>::value);
399 const auto *Exp = Nodes.getNodeAs<Expr>(NodeID<Expr>::value);
tools/clang/lib/Analysis/LiveVariables.cpp 238 if (const Expr *Ex = dyn_cast<Expr>(S))
238 if (const Expr *Ex = dyn_cast<Expr>(S))
265 if (isa<Expr>(S)) {
282 if (Expr *ImplicitObj = CE->getImplicitObjectArgument()) {
308 Expr *child = cast<PseudoObjectExpr>(S)->getResultExpr();
378 Expr *LHS = B->getLHS()->IgnoreParens();
443 else if ((DR = dyn_cast<DeclRefExpr>(cast<Expr>(element)->IgnoreParens()))) {
463 const Expr *subEx = UE->getArgumentExpr();
tools/clang/lib/Analysis/ReachableCode.cpp 33 static bool isEnumConstant(const Expr *Ex) {
40 static bool isTrivialExpression(const Expr *Ex) {
53 const Expr *Cond = DS->getCond()->IgnoreParenCasts();
96 if (const Expr *RE = RS->getRetValue()) {
195 if (const auto *Ex = dyn_cast<Expr>(S))
195 if (const auto *Ex = dyn_cast<Expr>(S))
198 if (const auto *Ex = dyn_cast<Expr>(S))
198 if (const auto *Ex = dyn_cast<Expr>(S))
207 if (const Expr *Ex = dyn_cast<Expr>(S))
207 if (const Expr *Ex = dyn_cast<Expr>(S))
225 const Expr *E = cast<Expr>(S);
225 const Expr *E = cast<Expr>(S);
550 if (const Expr *Ex = dyn_cast<Expr>(S))
550 if (const Expr *Ex = dyn_cast<Expr>(S))
554 case Expr::BinaryOperatorClass: {
558 case Expr::UnaryOperatorClass: {
563 case Expr::CompoundAssignOperatorClass: {
569 case Expr::BinaryConditionalOperatorClass:
570 case Expr::ConditionalOperatorClass: {
575 case Expr::MemberExprClass: {
580 case Expr::ArraySubscriptExprClass: {
586 case Expr::CStyleCastExprClass: {
591 case Expr::CXXFunctionalCastExprClass: {
599 case Expr::ObjCBridgedCastExprClass: {
637 const Expr *Inc = FS->getInc();
tools/clang/lib/Analysis/ThreadSafety.cpp 70 const Expr *MutexExp, const NamedDecl *D,
71 const Expr *DeclExp, StringRef Kind) {
395 const Expr *Exp = nullptr;
407 VarDefinition(const NamedDecl *D, const Expr *E, Context C)
439 const Expr* lookupExpr(const NamedDecl *D, Context &Ctx) {
486 const Expr *Exp = VarDefinitions[i].Exp;
528 Context addDefinition(const NamedDecl *D, const Expr *Exp, Context Ctx) {
546 Context updateDefinition(const NamedDecl *D, Expr *Exp, Context Ctx) {
612 const Expr *E = VD->getInit();
631 Expr *LHSExp = BO->getLHS()->IgnoreParenCasts();
1037 void getMutexIDs(CapExprSet &Mtxs, AttrType *Attr, const Expr *Exp,
1041 void getMutexIDs(CapExprSet &Mtxs, AttrType *Attr, const Expr *Exp,
1044 Expr *BrE, bool Neg);
1089 for (const auto *Arg : A->args()) {
1105 for (const auto *Arg : A->args()) {
1190 static const ValueDecl *getValueDecl(const Expr *Exp) {
1264 for (const auto *Arg : A->args()) {
1350 const Expr *Exp, const NamedDecl *D,
1365 for (const auto *Arg : Attr->args()) {
1382 const Expr *Exp, const NamedDecl *D,
1385 Expr *BrE, bool Neg) {
1406 static bool getStaticBooleanValue(Expr *E, bool &TCond) {
1442 const Expr *E = LocalVarMap.lookupExpr(DRE->getDecl(), C);
1579 void warnIfMutexNotHeld(const NamedDecl *D, const Expr *Exp, AccessKind AK,
1580 Expr *MutexExp, ProtectedOperationKind POK,
1582 void warnIfMutexHeld(const NamedDecl *D, const Expr *Exp, Expr *MutexExp,
1582 void warnIfMutexHeld(const NamedDecl *D, const Expr *Exp, Expr *MutexExp,
1585 void checkAccess(const Expr *Exp, AccessKind AK,
1587 void checkPtAccess(const Expr *Exp, AccessKind AK,
1590 void handleCall(const Expr *Exp, const NamedDecl *D, VarDecl *VD = nullptr);
1613 void BuildLockset::warnIfMutexNotHeld(const NamedDecl *D, const Expr *Exp,
1614 AccessKind AK, Expr *MutexExp,
1676 void BuildLockset::warnIfMutexHeld(const NamedDecl *D, const Expr *Exp,
1677 Expr *MutexExp, StringRef DiagKind) {
1698 void BuildLockset::checkAccess(const Expr *Exp, AccessKind AK,
1709 if (const auto *E = VD->getInit()) {
1754 void BuildLockset::checkPtAccess(const Expr *Exp, AccessKind AK,
1801 void BuildLockset::handleCall(const Expr *Exp, const NamedDecl *D,
1892 for (auto *Arg : A->args()) {
1908 for (auto *Arg : A->args())
2057 const Expr *Target = OE->getArg(0);
2058 const Expr *Source = OE->getArg(1);
2073 const Expr *Obj = OE->getArg(0);
2097 const Expr* Source = Exp->getArg(0);
2122 static Expr *buildFakeCtorCall(CXXConstructorDecl *CD, ArrayRef<Expr *> Args,
2122 static Expr *buildFakeCtorCall(CXXConstructorDecl *CD, ArrayRef<Expr *> Args,
2137 Expr *E = VD->getInit();
tools/clang/lib/Analysis/ThreadSafetyCommon.cpp 40 std::string threadSafety::getSourceLiteralString(const Expr *CE) {
83 static bool isCalleeArrow(const Expr *E) {
95 CapabilityExpr SExprBuilder::translateAttrExpr(const Expr *AttrExp,
97 const Expr *DeclExp,
151 CapabilityExpr SExprBuilder::translateAttrExpr(const Expr *AttrExp,
260 return new (Arena) til::Literal(cast<Expr>(S));
376 const Expr *SelfE) {
394 for (const auto *Arg : CE->arguments()) {
494 const Expr *LHS = BO->getLHS();
495 const Expr *RHS = BO->getRHS();
617 Expr *E = VD->getInit();
tools/clang/lib/Analysis/UninitializedValues.cpp 296 static const Expr *stripCasts(ASTContext &C, const Expr *Ex) {
296 static const Expr *stripCasts(ASTContext &C, const Expr *Ex) {
312 static FindVarResult findVar(const Expr *E, const DeclContext *DC) {
343 void classify(const Expr *E, Class C);
376 if (Expr *Init = VD->getInit()) {
385 void ClassifyRefs::classify(const Expr *E, Class C) {
461 classify(cast<Expr>(S), Use);
486 const Expr *Ex = stripCasts(DC->getParentASTContext(), *I);
532 void reportUse(const Expr *ex, const VarDecl *vd);
547 FindVarResult findVar(const Expr *ex) {
551 UninitUse getUninitUse(const Expr *ex, const VarDecl *vd, Value v) {
702 void TransferFunctions::reportUse(const Expr *ex, const VarDecl *vd) {
tools/clang/lib/Analysis/plugins/SampleAnalyzer/MainCallChecker.cpp 20 const Expr *Callee = CE->getCallee();
tools/clang/lib/CodeGen/Address.h 108 template <class U> inline U cast(CodeGen::Address addr) {
tools/clang/lib/CodeGen/CGAtomic.cpp 656 EmitValToTemp(CodeGenFunction &CGF, Expr *E) {
2005 void CodeGenFunction::EmitAtomicInit(Expr *init, LValue dest) {
tools/clang/lib/CodeGen/CGBlocks.cpp 435 const Expr *init = var->getInit();
1098 } else if (const Expr *copyExpr = CI.getCopyExpr()) {
2387 const Expr *CopyExpr;
2391 const Expr *copyExpr)
2623 const Expr *copyExpr =
tools/clang/lib/CodeGen/CGBuiltin.cpp 555 CodeGenFunction::evaluateOrEmitBuiltinObjectSize(const Expr *E, unsigned Type,
575 CodeGenFunction::emitBuiltinObjectSize(const Expr *E, unsigned Type,
1092 Value *CodeGenFunction::EmitCheckedArgForBuiltin(const Expr *E,
1249 } else if (const Expr *TheExpr = Item.getExpr()) {
1309 EmitCheckedMixedSignMultiply(CodeGenFunction &CGF, const clang::Expr *Op1,
1310 WidthAndSignedness Op1Info, const clang::Expr *Op2,
1312 const clang::Expr *ResultArg, QualType ResultQTy,
1319 const clang::Expr *SignedOp = Op1Info.Signed ? Op1 : Op2;
1320 const clang::Expr *UnsignedOp = Op1Info.Signed ? Op2 : Op1;
1536 Expr::EvalResult Result;
1855 const Expr *Arg0 = E->getArg(0)->IgnoreImpCasts();
2043 const Expr *Ptr = E->getArg(0);
2104 const Expr *Arg = E->getArg(0);
2412 Expr::EvalResult SizeResult, DstSizeResult;
2438 Expr::EvalResult SizeResult, DstSizeResult;
2478 Expr::EvalResult SizeResult, DstSizeResult;
2691 const Expr *Arg = E->getArg(0);
3113 for (const Expr *Arg : E->arguments()) {
3140 const Expr *AnnotationStrExpr = E->getArg(1)->IgnoreParenCasts();
3214 const clang::Expr *LeftArg = E->getArg(0);
3215 const clang::Expr *RightArg = E->getArg(1);
3216 const clang::Expr *ResultArg = E->getArg(2);
3383 const Expr *Chain = E->getArg(1);
3859 getContext(), Expr::NPC_ValueDependentIsNotNull)) {
3870 getContext(), Expr::NPC_ValueDependentIsNotNull)) {
5204 const Expr *Arg = E->getArg(0);
5242 const Expr *Arg = E->getArg(E->getNumArgs() - 1);
5925 const Expr *SysRegStrExpr = E->getArg(0)->IgnoreParenCasts();
6019 Expr::EvalResult Result;
6625 const Expr *Arg = E->getArg(E->getNumArgs()-1);
6932 const Expr *Arg = E->getArg(E->getNumArgs() - 1);
7247 Expr::EvalResult Result;
7492 const Expr *Arg = E->getArg(E->getNumArgs()-1);
9437 const Expr *Arg = E->getArg(0);
10005 const Expr *CPUExpr = E->getArg(0)->IgnoreParenCasts();
10068 const Expr *FeatureExpr = E->getArg(0)->IgnoreParenCasts();
tools/clang/lib/CodeGen/CGCXXABI.cpp 41 CodeGenFunction &CGF, const Expr *E, Address This,
58 CGCXXABI::EmitMemberDataPointerAddress(CodeGenFunction &CGF, const Expr *E,
tools/clang/lib/CodeGen/CGCXXABI.h 155 CodeGenFunction &CGF, const Expr *E, Address This,
161 EmitMemberDataPointerAddress(CodeGenFunction &CGF, const Expr *E,
tools/clang/lib/CodeGen/CGCall.cpp 3195 static const Expr *maybeGetUnaryAddrOfOperand(const Expr *E) {
3195 static const Expr *maybeGetUnaryAddrOfOperand(const Expr *E) {
3212 if (const Expr *lvExpr = maybeGetUnaryAddrOfOperand(CRE->getSubExpr())) {
3518 DisableDebugLocationUpdates(CodeGenFunction &CGF, const Expr *E) : CGF(CGF) {
3557 void CodeGenFunction::EmitCallArg(CallArgList &args, const Expr *E,
3626 QualType CodeGenFunction::getVarArgType(const Expr *Arg) {
3637 Expr::NPC_ValueDependentIsNotNull)) {
4566 if (const auto *Offset = AA->getOffset())
tools/clang/lib/CodeGen/CGClass.cpp 129 CodeGenFunction::EmitCXXMemberDataPointerAddress(const Expr *E, Address base,
527 static bool BaseInitializerUsesThis(ASTContext &C, const Expr *Init) {
669 Expr *Init) {
1180 Expr *DstPtr = CE->getArg(0);
1192 Expr *SrcPtr = CE->getArg(1);
1552 if (Expr *ThisArg = DD->getOperatorDeleteThisArg())
2058 const Expr *Arg = E->getArg(0);
tools/clang/lib/CodeGen/CGCoroutine.cpp 132 static bool memberCallExpressionCanThrow(const Expr *E) {
179 auto *E = S.getCommonExpr();
277 const Expr *RV = S.getOperand();
292 const auto *RE = E->getResumeExpr();
356 Expr const *InitExpr = VD->getInit();
734 for (const Expr *Arg : E->arguments())
tools/clang/lib/CodeGen/CGDebugInfo.cpp 121 ApplyDebugLocation::ApplyDebugLocation(CodeGenFunction &CGF, const Expr *E)
1834 const Expr *E = TA.getAsExpr();
2669 if (Expr *Size = VAT->getSizeExpr()) {
2670 Expr::EvalResult Result;
tools/clang/lib/CodeGen/CGDebugInfo.h 723 ApplyDebugLocation(CodeGenFunction &CGF, const Expr *E);
tools/clang/lib/CodeGen/CGDecl.cpp 632 if (const Expr *e = dyn_cast<Expr>(s)) {
632 if (const Expr *e = dyn_cast<Expr>(s)) {
656 static bool isAccessedBy(const ValueDecl *decl, const Expr *e) {
664 const LValue &destLV, const Expr *init) {
679 const Expr *srcExpr = castExpr->getSubExpr();
740 void CodeGenFunction::EmitScalarInit(const Expr *init, const ValueDecl *D,
1583 static bool isCapturedBy(const VarDecl &, const Expr *);
1588 if (const Expr *E = dyn_cast<Expr>(S))
1588 if (const Expr *E = dyn_cast<Expr>(S))
1598 static bool isCapturedBy(const VarDecl &Var, const Expr *E) {
1617 if (const auto *BIE = dyn_cast<Expr>(BI)) {
1617 if (const auto *BIE = dyn_cast<Expr>(BI)) {
1625 const Expr *Init = VD->getInit();
1647 bool CodeGenFunction::isTrivialInitializer(const Expr *Init) {
1753 const Expr *Init = D.getInit();
1867 void CodeGenFunction::EmitExprAsInit(const Expr *init, const ValueDecl *D,
tools/clang/lib/CodeGen/CGDeclCXX.cpp 39 const Expr *Init = D.getInit();
176 const Expr *Init = D.getInit();
tools/clang/lib/CodeGen/CGException.cpp 377 void CodeGenFunction::EmitAnyExprToExn(const Expr *e, Address addr) {
425 if (const Expr *SubExpr = E->getSubExpr()) {
1897 const Expr *FilterExpr = Except.getFilterExpr();
tools/clang/lib/CodeGen/CGExpr.cpp 164 llvm::Value *CodeGenFunction::EvaluateExprAsBool(const Expr *E) {
182 void CodeGenFunction::EmitIgnoredExpr(const Expr *E) {
194 RValue CodeGenFunction::EmitAnyExpr(const Expr *E,
213 RValue CodeGenFunction::EmitAnyExprToTemp(const Expr *E) {
223 void CodeGenFunction::EmitAnyExprToMem(const Expr *E,
255 const Expr *E, Address ReferenceTemporary) {
372 const Expr *Inner,
420 const Expr *E = M->GetTemporaryExpr();
472 SmallVector<const Expr *, 2> CommaLHSs;
593 CodeGenFunction::EmitReferenceBindingToExpr(const Expr *E) {
858 static bool isFlexibleArrayMemberExpr(const Expr *E) {
886 llvm::Value *CodeGenFunction::LoadPassedObjectSize(const Expr *E,
928 CodeGenFunction &CGF, const Expr *Base, QualType &IndexedType) {
959 void CodeGenFunction::EmitBoundsCheck(const Expr *E, const Expr *Base,
959 void CodeGenFunction::EmitBoundsCheck(const Expr *E, const Expr *Base,
1036 Address CodeGenFunction::EmitPointerWithAlignment(const Expr *E,
1170 RValue CodeGenFunction::EmitUnsupportedRValue(const Expr *E,
1176 LValue CodeGenFunction::EmitUnsupportedLValue(const Expr *E,
1184 bool CodeGenFunction::IsWrappedCXXThis(const Expr *Obj) {
1185 const Expr *Base = Obj;
1207 LValue CodeGenFunction::EmitCheckedLValue(const Expr *E, TypeCheckKind TCK) {
1243 LValue CodeGenFunction::EmitLValue(const Expr *E) {
1248 case Expr::ObjCPropertyRefExprClass:
1251 case Expr::ObjCSelectorExprClass:
1253 case Expr::ObjCIsaExprClass:
1255 case Expr::BinaryOperatorClass:
1257 case Expr::CompoundAssignOperatorClass: {
1265 case Expr::CallExprClass:
1266 case Expr::CXXMemberCallExprClass:
1267 case Expr::CXXOperatorCallExprClass:
1268 case Expr::UserDefinedLiteralClass:
1270 case Expr::CXXRewrittenBinaryOperatorClass:
1272 case Expr::VAArgExprClass:
1274 case Expr::DeclRefExprClass:
1276 case Expr::ConstantExprClass:
1278 case Expr::ParenExprClass:
1280 case Expr::GenericSelectionExprClass:
1282 case Expr::PredefinedExprClass:
1284 case Expr::StringLiteralClass:
1286 case Expr::ObjCEncodeExprClass:
1288 case Expr::PseudoObjectExprClass:
1290 case Expr::InitListExprClass:
1292 case Expr::CXXTemporaryObjectExprClass:
1293 case Expr::CXXConstructExprClass:
1295 case Expr::CXXBindTemporaryExprClass:
1297 case Expr::CXXUuidofExprClass:
1299 case Expr::LambdaExprClass:
1302 case Expr::ExprWithCleanupsClass: {
1320 case Expr::CXXDefaultArgExprClass: {
1325 case Expr::CXXDefaultInitExprClass: {
1330 case Expr::CXXTypeidExprClass:
1333 case Expr::ObjCMessageExprClass:
1335 case Expr::ObjCIvarRefExprClass:
1337 case Expr::StmtExprClass:
1339 case Expr::UnaryOperatorClass:
1341 case Expr::ArraySubscriptExprClass:
1343 case Expr::OMPArraySectionExprClass:
1345 case Expr::ExtVectorElementExprClass:
1347 case Expr::MemberExprClass:
1349 case Expr::CompoundLiteralExprClass:
1351 case Expr::ConditionalOperatorClass:
1353 case Expr::BinaryConditionalOperatorClass:
1355 case Expr::ChooseExprClass:
1357 case Expr::OpaqueValueExprClass:
1359 case Expr::SubstNonTypeTemplateParmExprClass:
1361 case Expr::ImplicitCastExprClass:
1362 case Expr::CStyleCastExprClass:
1363 case Expr::CXXFunctionalCastExprClass:
1364 case Expr::CXXStaticCastExprClass:
1365 case Expr::CXXDynamicCastExprClass:
1366 case Expr::CXXReinterpretCastExprClass:
1367 case Expr::CXXConstCastExprClass:
1368 case Expr::ObjCBridgedCastExprClass:
1371 case Expr::MaterializeTemporaryExprClass:
1374 case Expr::CoawaitExprClass:
1376 case Expr::CoyieldExprClass:
1449 Expr::EvalResult result;
1515 const CodeGenFunction::ConstantEmission &Constant, Expr *E) {
2187 static void setObjCGCLValueClass(const ASTContext &Ctx, const Expr *E,
2361 const Expr *E, const VarDecl *VD) {
2421 const Expr *E, const FunctionDecl *FD) {
3314 Address CodeGenFunction::EmitArrayToPointerDecay(const Expr *E,
3351 static const Expr *isSimpleArrayDecayOperand(const Expr *E) {
3351 static const Expr *isSimpleArrayDecayOperand(const Expr *E) {
3358 const Expr *SubExpr = CE->getSubExpr();
3563 } else if (const Expr *Array = isSimpleArrayDecayOperand(E->getBase())) {
3607 static Address emitOMPArraySectionBase(CodeGenFunction &CGF, const Expr *Base,
3765 } else if (const Expr *Array = isSimpleArrayDecayOperand(E->getBase())) {
3863 Expr *BaseExpr = E->getBase();
4172 const Expr *InitExpr = E->getInitializer();
4195 const Expr *Operand) {
4215 const Expr *condExpr = expr->getCond();
4218 const Expr *live = expr->getTrueExpr(), *dead = expr->getFalseExpr();
4555 CGCallee CodeGenFunction::EmitCallee(const Expr *E) {
4744 const Expr *BaseExpr = E->getBase();
5022 const Expr *resultExpr = E->getResultExpr();
5027 const Expr *semantic = *i;
tools/clang/lib/CodeGen/CGExprAgg.cpp 56 void withReturnValueSlot(const Expr *E,
71 void EmitAggLoadOfLValue(const Expr *E);
86 void EmitMoveFromReturnSlot(const Expr *E, RValue Src);
103 void Visit(Expr *E) {
200 void EmitInitializationToLValue(Expr *E, LValue Address);
218 void AggExprEmitter::EmitAggLoadOfLValue(const Expr *E) {
248 const Expr *E, llvm::function_ref<RValue(ReturnValueSlot)> EmitCall) {
447 static bool isTrivialFiller(Expr *E) {
565 Expr *filler = E->getArrayFiller();
667 static Expr *findPeephole(Expr *op, CastKind kind) {
667 static Expr *findPeephole(Expr *op, CastKind kind) {
766 if (Expr *op = findPeephole(E->getSubExpr(), peepholeTarget)) {
1074 static bool isBlockVarRef(const Expr *E) {
1109 if (const Expr *src = op->getSourceExpr())
1361 static bool isSimpleZero(const Expr *E, CodeGenFunction &CGF) {
1389 AggExprEmitter::EmitInitializationToLValue(Expr *E, LValue LV) {
1746 static CharUnits GetNumNonZeroBytesInInit(const Expr *E, CodeGenFunction &CGF) {
1782 const Expr *E = ILE->getInit(ILEElement++);
1806 static void CheckAggExprForMemSetUse(AggValueSlot &Slot, const Expr *E,
1851 void CodeGenFunction::EmitAggExpr(const Expr *E, AggValueSlot Slot) {
1863 LValue CodeGenFunction::EmitAggExprToLValue(const Expr *E) {
tools/clang/lib/CodeGen/CGExprCXX.cpp 125 Expr *BaseExpr = E->getBase();
169 static CXXRecordDecl *getCXXRecord(const Expr *E) {
181 const Expr *callee = CE->getCallee()->IgnoreParens();
200 const Expr *Base = ME->getBase();
209 const Expr *Base) {
222 const Expr *Inner = Base->ignoreParenBaseCasts();
324 auto *IOA = CMCE->getImplicitObjectArgument();
418 const Expr *BaseExpr = BO->getLHS();
419 const Expr *MemFnExpr = BO->getRHS();
639 const Expr *Exp) {
935 static void StoreAnyExprIntoOneUnit(CodeGenFunction &CGF, const Expr *Init,
976 const Expr *Init = E->getInitializer();
1278 else if (const Expr *Init = E->getInitializer())
1566 const Expr *arg = *E->placement_arguments().begin();
1883 const Expr *Base = DE->getArgument();
2015 const Expr *Arg = E->getArgument();
2071 static bool isGLValueFromPointerDeref(const Expr *E) {
2103 static llvm::Value *EmitTypeidFromVTable(CodeGenFunction &CGF, const Expr *E,
tools/clang/lib/CodeGen/CGExprComplex.cpp 72 ComplexPairTy EmitLoadOfLValue(const Expr *E) {
93 ComplexPairTy Visit(Expr *E) {
102 ComplexPairTy VisitExpr(Expr *S);
126 Expr *E) {
149 ComplexPairTy VisitArraySubscriptExpr(Expr *E) { return EmitLoadOfLValue(E); }
171 ComplexPairTy EmitCast(CastKind CK, Expr *Op, QualType DestTy);
203 ComplexPairTy VisitUnaryDeref(const Expr *E) { return EmitLoadOfLValue(E); }
391 ComplexPairTy ComplexExprEmitter::VisitExpr(Expr *E) {
450 ComplexPairTy ComplexExprEmitter::EmitCast(CastKind CK, Expr *Op,
1106 ComplexPairTy CodeGenFunction::EmitComplexExpr(const Expr *E, bool IgnoreReal,
1115 void CodeGenFunction::EmitComplexExprIntoLValue(const Expr *E, LValue dest,
tools/clang/lib/CodeGen/CGExprConstant.cpp 625 if (Expr *Filler = Updater->getArrayFiller()) {
636 Expr *Init = nullptr;
689 Expr *Init = nullptr;
1031 Expr *subExpr = E->getSubExpr();
1193 if (Expr *filler = ILE->getArrayFiller()) {
1208 Expr *Init = ILE->getInit(i);
1289 Expr *Arg = E->getArg(0);
1350 ConstantEmitter::tryEmitAbstract(const Expr *E, QualType destType) {
1364 ConstantEmitter::emitAbstract(const Expr *E, QualType destType) {
1395 llvm::Constant *ConstantEmitter::tryEmitForInitializer(const Expr *E,
1629 const Expr *E = D.getInit();
1639 ConstantEmitter::tryEmitAbstractForMemory(const Expr *E, QualType destType) {
1653 llvm::Constant *ConstantEmitter::tryEmitPrivateForMemory(const Expr *E,
1698 llvm::Constant *ConstantEmitter::tryEmitPrivate(const Expr *E,
1700 Expr::EvalResult Result;
1901 return Visit(base.get<const Expr*>());
2004 SmallVector<const Expr *, 2> CommaLHSs;
2006 const Expr *Inner = E->GetTemporaryExpr()
tools/clang/lib/CodeGen/CGExprScalar.cpp 92 const Expr *E; // Entire expr, for error unsupported. May not be binop.
145 static bool MustVisitNullValue(const Expr *E) {
154 const Expr *E) {
155 const Expr *Base = E->IgnoreImpCasts();
168 static bool IsWidenedIntegerOp(const ASTContext &Ctx, const Expr *E) {
253 LValue EmitLValue(const Expr *E) { return CGF.EmitLValue(E); }
254 LValue EmitCheckedLValue(const Expr *E, CodeGenFunction::TypeCheckKind TCK) {
265 void EmitLValueAlignmentAssumption(const Expr *E, Value *V) {
303 Value *EmitLoadOfLValue(const Expr *E) {
421 Value *Visit(Expr *E) {
430 Value *VisitExpr(Expr *S);
554 Value *VisitExtVectorElementExpr(Expr *E) { return EmitLoadOfLValue(E); }
817 Value *VisitBinPtrMemD(const Expr *E) { return EmitLoadOfLValue(E); }
818 Value *VisitBinPtrMemI(const Expr *E) { return EmitLoadOfLValue(E); }
1583 Value *ScalarExprEmitter::VisitExpr(Expr *E) {
1724 Expr::EvalResult Result;
1725 if (E->EvaluateAsInt(Result, CGF.getContext(), Expr::SE_AllowSideEffects)) {
1807 Expr *IE = E->getInit(i);
1934 const Expr *E = CE->getSubExpr();
1957 Expr *E = CE->getSubExpr();
2038 Expr::EvalResult Result;
2637 Expr::EvalResult EVResult;
2654 Expr *IdxExpr = E->getIndexExpr(ON.getArrayExprIndex());
2769 Expr *Op = E->getSubExpr();
2786 Expr *Op = E->getSubExpr();
3165 Expr *pointerOperand = expr->getLHS();
3167 Expr *indexOperand = expr->getRHS();
4138 static bool isCheapEnoughToEvaluateUnconditionally(const Expr *E,
4159 Expr *condExpr = E->getCond();
4160 Expr *lhsExpr = E->getTrueExpr();
4161 Expr *rhsExpr = E->getFalseExpr();
4167 Expr *live = lhsExpr, *dead = rhsExpr;
4440 Value *CodeGenFunction::EmitScalarExpr(const Expr *E, bool IgnoreResultAssign) {
4481 Expr *BaseExpr = E->getBase();
tools/clang/lib/CodeGen/CGLoopInfo.cpp 607 auto *ValueExpr = LH->getValue();
tools/clang/lib/CodeGen/CGObjC.cpp 63 const Expr *SubExpr = E->getSubExpr();
117 llvm::Value *CodeGenFunction::EmitObjCCollectionLiteral(const Expr *E,
166 const Expr *Rhs = ALE->getElement(i);
177 const Expr *Key = DLE->getKeyValueElement(i).Key;
184 const Expr *Value = DLE->getKeyValueElement(i).Value;
290 const Expr *receiver = message->getInstanceReceiver();
343 static const Expr *findWeakLValue(const Expr *E) {
343 static const Expr *findWeakLValue(const Expr *E) {
459 const Expr *SelfInClassMethod = nullptr;
968 const Expr *getter = propImpl->getGetterCXXConstructor();
1281 Expr *setter = PID->getSetterCXXAssignment();
1473 Expr *finalArg = &argLoad;
1806 elementType = cast<Expr>(S.getElement())->getType();
1832 elementLValue = EmitLValue(cast<Expr>(S.getElement()));
1900 elementLValue = EmitLValue(cast<Expr>(S.getElement()));
2812 const Expr *e) {
2826 const Expr *e) {
2837 llvm::Value *CodeGenFunction::EmitARCReclaimReturnedObject(const Expr *E,
2851 static bool shouldEmitSeparateBlockRetain(const Expr *e) {
2895 Result visit(const Expr *e);
2928 const Expr *resultExpr = E->getResultExpr();
2934 const Expr *semantic = *i;
3091 Result ARCExprEmitter<Impl,Result>::visit(const Expr *e) {
3240 llvm::Value *CodeGenFunction::EmitARCRetainScalarExpr(const Expr *e) {
3256 CodeGenFunction::EmitARCRetainAutoreleaseScalarExpr(const Expr *e) {
3273 llvm::Value *CodeGenFunction::EmitARCExtendBlockObject(const Expr *e) {
3291 llvm::Value *CodeGenFunction::EmitObjCThrowOperand(const Expr *expr) {
3323 llvm::Value *visitLValueToRValue(const Expr *e) {
3329 llvm::Value *visitConsumeObject(const Expr *e) {
3336 llvm::Value *visitExtendBlockObject(const Expr *e) {
3341 llvm::Value *visitReclaimReturnedObject(const Expr *e) {
3347 llvm::Value *visitCall(const Expr *e) {
3352 llvm::Value *visitExpr(const Expr *e) {
3359 const Expr *e) {
3367 llvm::Value *CodeGenFunction::EmitARCUnsafeUnretainedScalarExpr(const Expr *e) {
3553 Expr *Args[2] = { &DST, &SRC };
3635 SmallVector<Expr*, 4> ConstructorArgs;
tools/clang/lib/CodeGen/CGObjCGNU.cpp 3937 if (const Expr *ThrowExpr = S.getThrowExpr()) {
tools/clang/lib/CodeGen/CGObjCMac.cpp 4765 if (const Expr *ThrowExpr = S.getThrowExpr()) {
7666 if (const Expr *ThrowExpr = S.getThrowExpr()) {
tools/clang/lib/CodeGen/CGObjCRuntime.cpp 332 const Expr *lockExpr = S.getSynchExpr();
tools/clang/lib/CodeGen/CGOpenCLRuntime.cpp 98 llvm::Value *CGOpenCLRuntime::getPipeElemSize(const Expr *PipeArg) {
108 llvm::Value *CGOpenCLRuntime::getPipeElemAlign(const Expr *PipeArg) {
130 static const BlockExpr *getBlockExpr(const Expr *E) {
131 const Expr *Prev = nullptr; // to make sure we do not stuck in infinite loop.
156 llvm::Function *CGOpenCLRuntime::getInvokeFunction(const Expr *E) {
161 CGOpenCLRuntime::emitOpenCLEnqueuedBlock(CodeGenFunction &CGF, const Expr *E) {
tools/clang/lib/CodeGen/CGOpenCLRuntime.h 49 llvm::DenseMap<const Expr *, EnqueuedBlockInfo> EnqueuedBlockMap;
73 virtual llvm::Value *getPipeElemSize(const Expr *PipeArg);
77 virtual llvm::Value *getPipeElemAlign(const Expr *PipeArg);
84 const Expr *E);
97 llvm::Function *getInvokeFunction(const Expr *E);
tools/clang/lib/CodeGen/CGOpenMPRuntime.cpp 792 getReductionInit(const Expr *ReductionOp) {
804 const Expr *InitOp,
812 const Expr *LHS = CE->getArg(/*Arg=*/0)->IgnoreParenImpCasts();
813 const Expr *RHS = CE->getArg(/*Arg=*/1)->IgnoreParenImpCasts();
861 const Expr *Init,
943 LValue ReductionCodeGen::emitSharedLValue(CodeGenFunction &CGF, const Expr *E) {
948 const Expr *E) {
971 ReductionCodeGen::ReductionCodeGen(ArrayRef<const Expr *> Shareds,
972 ArrayRef<const Expr *> Privates,
973 ArrayRef<const Expr *> ReductionOps) {
980 for (const Expr *Ref : Shareds) {
1152 static const VarDecl *getBaseDecl(const Expr *Ref, const DeclRefExpr *&DE) {
1155 const Expr *Base = OASE->getBase()->IgnoreParenImpCasts();
1163 const Expr *Base = ASE->getBase()->IgnoreParenImpCasts();
1349 const Expr *CombinerInitializer, const VarDecl *In,
1414 if (const Expr *Init = D->getInitializer()) {
2766 const Expr *Init = VD->getAnyInitializer();
2907 const Expr *Init = VD->getAnyInitializer();
3011 void CGOpenMPRuntime::emitOMPIfClause(CodeGenFunction &CGF, const Expr *Cond,
3053 const Expr *IfCond) {
3201 SourceLocation Loc, const Expr *Hint) {
3289 ArrayRef<const Expr *> CopyprivateVars, ArrayRef<const Expr *> DestExprs,
3289 ArrayRef<const Expr *> CopyprivateVars, ArrayRef<const Expr *> DestExprs,
3290 ArrayRef<const Expr *> SrcExprs, ArrayRef<const Expr *> AssignmentOps,
3290 ArrayRef<const Expr *> SrcExprs, ArrayRef<const Expr *> AssignmentOps,
3344 ArrayRef<const Expr *> CopyprivateVars,
3345 ArrayRef<const Expr *> SrcExprs,
3346 ArrayRef<const Expr *> DstExprs,
3347 ArrayRef<const Expr *> AssignmentOps) {
3460 OpenMPScheduleClauseKind &ScheduleKind, const Expr *&ChunkExpr) const {
3844 void CGOpenMPRuntime::emitFlush(CodeGenFunction &CGF, ArrayRef<const Expr *>,
4659 ArrayRef<const Expr *> PrivateVars,
4660 ArrayRef<const Expr *> FirstprivateVars,
4661 ArrayRef<const Expr *> LastprivateVars,
4673 for (const Expr *E : PrivateVars) {
4684 for (const Expr *E : FirstprivateVars) {
4695 for (const Expr *E : LastprivateVars) {
4779 const Expr *Init = VD->getAnyInitializer();
4857 const Expr *Init = VD->getAnyInitializer();
4970 for (const Expr *E : Data.PrivateVars) {
4980 for (const Expr *E : Data.FirstprivateVars) {
4991 for (const Expr *E : Data.LastprivateVars) {
5095 const Expr *Device = nullptr;
5185 const Expr *IfCond,
5228 const Expr *E = Data.Dependences[I].second;
5380 const Expr *IfCond,
5469 const llvm::function_ref<void(CodeGenFunction &CGF, const Expr *,
5470 const Expr *, const Expr *)> &RedOpGen,
5470 const Expr *, const Expr *)> &RedOpGen,
5471 const Expr *XExpr = nullptr, const Expr *EExpr = nullptr,
5471 const Expr *XExpr = nullptr, const Expr *EExpr = nullptr,
5472 const Expr *UpExpr = nullptr) {
5541 const Expr *ReductionOp) {
5559 SourceLocation Loc, llvm::Type *ArgsType, ArrayRef<const Expr *> Privates,
5560 ArrayRef<const Expr *> LHSExprs, ArrayRef<const Expr *> RHSExprs,
5560 ArrayRef<const Expr *> LHSExprs, ArrayRef<const Expr *> RHSExprs,
5561 ArrayRef<const Expr *> ReductionOps) {
5627 for (const Expr *E : ReductionOps) {
5651 const Expr *ReductionOp,
5652 const Expr *PrivateRef,
5671 ArrayRef<const Expr *> Privates,
5672 ArrayRef<const Expr *> LHSExprs,
5673 ArrayRef<const Expr *> RHSExprs,
5674 ArrayRef<const Expr *> ReductionOps,
5724 for (const Expr *E : ReductionOps) {
5737 for (const Expr *E : Privates) {
5827 for (const Expr *E : ReductionOps) {
5860 for (const Expr *E : ReductionOps) {
5861 const Expr *XExpr = nullptr;
5862 const Expr *EExpr = nullptr;
5863 const Expr *UpExpr = nullptr;
5872 const Expr *RHSExpr = UpExpr;
5977 const Expr *Ref) {
6072 const Expr *ReductionOp,
6073 const Expr *LHS, const Expr *RHS,
6073 const Expr *LHS, const Expr *RHS,
6074 const Expr *PrivateRef) {
6187 CodeGenFunction &CGF, SourceLocation Loc, ArrayRef<const Expr *> LHSExprs,
6188 ArrayRef<const Expr *> RHSExprs, const OMPTaskDataTy &Data) {
6420 const Expr *IfCond,
6540 static bool isTrivial(ASTContext &Ctx, const Expr * E) {
6543 return (E->isEvaluatable(Ctx, Expr::SE_AllowUndefinedBehavior) ||
6554 if (const auto *E = dyn_cast<Expr>(S)) {
6554 if (const auto *E = dyn_cast<Expr>(S)) {
6624 const Expr *NumTeams =
6648 const Expr *NumTeams =
6740 const Expr *Cond = IfClause->getCondition();
6931 const Expr *Cond = IfClause->getCondition();
7142 const Expr *IE = nullptr;
7145 DeferredDevicePtrEntryTy(const Expr *IE, const ValueDecl *VD)
7170 llvm::Value *getExprTypeSize(const Expr *E) const {
7206 if (const Expr *LenExpr = OAE->getLength()) {
7278 bool isFinalArraySectionExpression(const Expr *E) const {
7289 const Expr *Length = OASE->getLength();
7307 Expr::EvalResult Result;
7501 const Expr *AssocExpr = I->getAssociatedExpression();
7863 for (const auto *D : C->varlists())
7971 const Expr *IE = L.second.back().getAssociatedExpression();
9161 llvm::Function *OutlinedFn, llvm::Value *OutlinedFnID, const Expr *IfCond,
9162 const Expr *Device,
9920 const Expr *NumTeams,
9921 const Expr *ThreadLimit,
9948 CodeGenFunction &CGF, const OMPExecutableDirective &D, const Expr *IfCond,
9949 const Expr *Device, const RegionCodeGenTy &CodeGen, TargetDataInfo &Info) {
10075 CodeGenFunction &CGF, const OMPExecutableDirective &D, const Expr *IfCond,
10076 const Expr *Device) {
10686 for (const Expr *E : Attr->uniforms()) {
10700 for (const Expr *E : Attr->aligneds()) {
10724 for (const Expr *E : Attr->linears()) {
10737 Expr::EvalResult Result;
10738 if (!(*SI)->EvaluateAsInt(Result, C, Expr::SE_AllowSideEffects)) {
10756 const Expr *VLENExpr = Attr->getSimdlen();
10807 ArrayRef<Expr *> NumIterations) {
10886 const Expr *CounterVal = C->getLoopData(I);
11041 static bool greaterCtxScore(ASTContext &Ctx, const Expr *LHS, const Expr *RHS) {
11041 static bool greaterCtxScore(ASTContext &Ctx, const Expr *LHS, const Expr *RHS) {
11066 const Expr *LHSExpr = nullptr;
11067 const Expr *RHSExpr = nullptr;
11086 const Expr *LHSExpr = nullptr;
11087 const Expr *RHSExpr = nullptr;
11170 const Expr *IfCond) {
11177 const Expr *Hint) {
11200 SourceLocation Loc, ArrayRef<const Expr *> CopyprivateVars,
11201 ArrayRef<const Expr *> DestExprs, ArrayRef<const Expr *> SrcExprs,
11201 ArrayRef<const Expr *> DestExprs, ArrayRef<const Expr *> SrcExprs,
11202 ArrayRef<const Expr *> AssignmentOps) {
11292 ArrayRef<const Expr *> Vars,
11301 const Expr *IfCond,
11309 const Expr *IfCond, const OMPTaskDataTy &Data) {
11314 CodeGenFunction &CGF, SourceLocation Loc, ArrayRef<const Expr *> Privates,
11315 ArrayRef<const Expr *> LHSExprs, ArrayRef<const Expr *> RHSExprs,
11315 ArrayRef<const Expr *> LHSExprs, ArrayRef<const Expr *> RHSExprs,
11316 ArrayRef<const Expr *> ReductionOps, ReductionOptionsTy Options) {
11323 CodeGenFunction &CGF, SourceLocation Loc, ArrayRef<const Expr *> LHSExprs,
11324 ArrayRef<const Expr *> RHSExprs, const OMPTaskDataTy &Data) {
11354 SourceLocation Loc, const Expr *IfCond,
11368 llvm::Function *OutlinedFn, llvm::Value *OutlinedFnID, const Expr *IfCond,
11369 const Expr *Device,
11397 const Expr *NumTeams,
11398 const Expr *ThreadLimit,
11404 CodeGenFunction &CGF, const OMPExecutableDirective &D, const Expr *IfCond,
11405 const Expr *Device, const RegionCodeGenTy &CodeGen, TargetDataInfo &Info) {
11410 CodeGenFunction &CGF, const OMPExecutableDirective &D, const Expr *IfCond,
11411 const Expr *Device) {
11417 ArrayRef<Expr *> NumIterations) {
tools/clang/lib/CodeGen/CGOpenMPRuntime.h 92 SmallVector<const Expr *, 4> PrivateVars;
93 SmallVector<const Expr *, 4> PrivateCopies;
94 SmallVector<const Expr *, 4> FirstprivateVars;
95 SmallVector<const Expr *, 4> FirstprivateCopies;
96 SmallVector<const Expr *, 4> FirstprivateInits;
97 SmallVector<const Expr *, 4> LastprivateVars;
98 SmallVector<const Expr *, 4> LastprivateCopies;
99 SmallVector<const Expr *, 4> ReductionVars;
100 SmallVector<const Expr *, 4> ReductionCopies;
101 SmallVector<const Expr *, 4> ReductionOps;
102 SmallVector<std::pair<OpenMPDependClauseKind, const Expr *>, 4> Dependences;
118 const Expr *Ref = nullptr;
120 const Expr *Private = nullptr;
122 const Expr *ReductionOp = nullptr;
123 ReductionData(const Expr *Ref, const Expr *Private, const Expr *ReductionOp)
123 ReductionData(const Expr *Ref, const Expr *Private, const Expr *ReductionOp)
123 ReductionData(const Expr *Ref, const Expr *Private, const Expr *ReductionOp)
137 LValue emitSharedLValue(CodeGenFunction &CGF, const Expr *E);
139 LValue emitSharedLValueUB(CodeGenFunction &CGF, const Expr *E);
150 ReductionCodeGen(ArrayRef<const Expr *> Shareds,
151 ArrayRef<const Expr *> Privates,
152 ArrayRef<const Expr *> ReductionOps);
195 const Expr *getRefExpr(unsigned N) const { return ClausesData[N].Ref; }
251 void emitOMPIfClause(CodeGenFunction &CGF, const Expr *Cond,
903 const Expr *IfCond);
913 const Expr *Hint = nullptr);
938 ArrayRef<const Expr *> CopyprivateVars,
939 ArrayRef<const Expr *> DestExprs,
940 ArrayRef<const Expr *> SrcExprs,
941 ArrayRef<const Expr *> AssignmentOps);
1198 virtual void emitFlush(CodeGenFunction &CGF, ArrayRef<const Expr *> Vars,
1231 Address Shareds, const Expr *IfCond,
1267 const Expr *IfCond, const OMPTaskDataTy &Data);
1290 ArrayRef<const Expr *> Privates,
1291 ArrayRef<const Expr *> LHSExprs,
1292 ArrayRef<const Expr *> RHSExprs,
1293 ArrayRef<const Expr *> ReductionOps);
1297 const Expr *ReductionOp,
1298 const Expr *PrivateRef,
1350 ArrayRef<const Expr *> Privates,
1351 ArrayRef<const Expr *> LHSExprs,
1352 ArrayRef<const Expr *> RHSExprs,
1353 ArrayRef<const Expr *> ReductionOps,
1378 ArrayRef<const Expr *> LHSExprs,
1379 ArrayRef<const Expr *> RHSExprs,
1418 const Expr *IfCond,
1452 const Expr *IfCond, const Expr *Device,
1452 const Expr *IfCond, const Expr *Device,
1509 virtual void emitNumTeamsClause(CodeGenFunction &CGF, const Expr *NumTeams,
1510 const Expr *ThreadLimit, SourceLocation Loc);
1562 const Expr *IfCond, const Expr *Device,
1562 const Expr *IfCond, const Expr *Device,
1575 const Expr *IfCond,
1576 const Expr *Device);
1588 ArrayRef<Expr *> NumIterations);
1622 const Expr *&ChunkExpr) const;
1736 const Expr *IfCond) override;
1746 const Expr *Hint = nullptr) override;
1770 ArrayRef<const Expr *> CopyprivateVars,
1771 ArrayRef<const Expr *> DestExprs,
1772 ArrayRef<const Expr *> SrcExprs,
1773 ArrayRef<const Expr *> AssignmentOps) override;
1929 void emitFlush(CodeGenFunction &CGF, ArrayRef<const Expr *> Vars,
1962 Address Shareds, const Expr *IfCond,
1996 QualType SharedsTy, Address Shareds, const Expr *IfCond,
2042 ArrayRef<const Expr *> Privates,
2043 ArrayRef<const Expr *> LHSExprs,
2044 ArrayRef<const Expr *> RHSExprs,
2045 ArrayRef<const Expr *> ReductionOps,
2069 ArrayRef<const Expr *> LHSExprs,
2070 ArrayRef<const Expr *> RHSExprs,
2108 const Expr *IfCond,
2140 const Expr *IfCond, const Expr *Device,
2140 const Expr *IfCond, const Expr *Device,
2178 void emitNumTeamsClause(CodeGenFunction &CGF, const Expr *NumTeams,
2179 const Expr *ThreadLimit, SourceLocation Loc) override;
2190 const OMPExecutableDirective &D, const Expr *IfCond,
2191 const Expr *Device, const RegionCodeGenTy &CodeGen,
2203 const Expr *IfCond,
2204 const Expr *Device) override;
2209 ArrayRef<Expr *> NumIterations) override;
tools/clang/lib/CodeGen/CGOpenMPRuntimeNVPTX.cpp 206 static const ValueDecl *getPrivateItem(const Expr *RefExpr) {
209 const Expr *Base = ASE->getBase()->IgnoreParenImpCasts();
214 const Expr *Base = OASE->getBase()->IgnoreParenImpCasts();
399 ArrayRef<const Expr *> Vars;
406 for (const auto *E : Vars) {
514 for (const Expr *Arg : E->arguments()) {
564 void VisitExpr(const Expr *E) {
1947 const Expr *NumTeams,
1948 const Expr *ThreadLimit,
2016 for (const Expr *E : C->getVarRefs())
2028 for (const Expr *E : C->privates())
2475 ArrayRef<llvm::Value *> CapturedVars, const Expr *IfCond) {
2487 ArrayRef<llvm::Value *> CapturedVars, const Expr *IfCond) {
2656 ArrayRef<llvm::Value *> CapturedVars, const Expr *IfCond) {
2746 const Expr *Hint) {
2963 ArrayRef<const Expr *> Privates, Address SrcBase, Address DestBase,
2978 for (const Expr *Private : Privates) {
3168 ArrayRef<const Expr *> Privates,
3238 for (const Expr *Private : Privates) {
3460 CodeGenModule &CGM, ArrayRef<const Expr *> Privates,
3622 CodeGenModule &CGM, ArrayRef<const Expr *> Privates,
3674 for (const Expr *Private : Privates) {
3727 CodeGenModule &CGM, ArrayRef<const Expr *> Privates,
3822 CodeGenModule &CGM, ArrayRef<const Expr *> Privates,
3875 for (const Expr *Private : Privates) {
3927 CodeGenModule &CGM, ArrayRef<const Expr *> Privates,
4258 CodeGenFunction &CGF, SourceLocation Loc, ArrayRef<const Expr *> Privates,
4259 ArrayRef<const Expr *> LHSExprs, ArrayRef<const Expr *> RHSExprs,
4259 ArrayRef<const Expr *> LHSExprs, ArrayRef<const Expr *> RHSExprs,
4260 ArrayRef<const Expr *> ReductionOps, ReductionOptionsTy Options) {
4292 for (const Expr *E : Privates) {
4354 for (const Expr *DRE : Privates) {
4420 for (const Expr *E : ReductionOps) {
4836 const Expr *&ChunkExpr) const {
tools/clang/lib/CodeGen/CGOpenMPRuntimeNVPTX.h 160 const Expr *IfCond);
176 const Expr *IfCond);
231 void emitNumTeamsClause(CodeGenFunction &CGF, const Expr *NumTeams,
232 const Expr *ThreadLimit, SourceLocation Loc) override;
288 const Expr *IfCond) override;
310 const Expr *Hint = nullptr) override;
326 ArrayRef<const Expr *> Privates,
327 ArrayRef<const Expr *> LHSExprs,
328 ArrayRef<const Expr *> RHSExprs,
329 ArrayRef<const Expr *> ReductionOps,
389 const Expr *&ChunkExpr) const override;
tools/clang/lib/CodeGen/CGStmt.cpp 112 EmitIgnoredExpr(cast<Expr>(S));
408 while (!isa<Expr>(ExprResult)) {
423 const Expr *E = cast<Expr>(ExprResult);
423 const Expr *E = cast<Expr>(ExprResult);
1073 const Expr *RV = S.getRetValue();
1787 AddVariableConstraints(const std::string &Constraint, const Expr &AsmExpr,
1850 const Expr *InputExpr,
1856 Expr::EvalResult EVResult;
1865 Expr::EvalResult Result;
1873 if (InputExpr->getStmtClass() == Expr::CXXThisExprClass)
2024 const Expr *OutExpr = S.getOutputExpr(i);
2100 const Expr *InputExpr = S.getOutputExpr(i);
2139 const Expr *InputExpr = S.getInputExpr(i);
2337 const Expr *OutExpr = S.getOutputExpr(i);
tools/clang/lib/CodeGen/CGStmtOpenMP.cpp 124 for (const auto *E : S.counters()) {
132 for (const Expr *IRef : C->varlists()) {
206 for (const Expr *E : UDP->varlists()) {
216 if (const Expr *E = TG->getReductionRef())
249 LValue CodeGenFunction::EmitOMPSharedLValue(const Expr *E) {
387 llvm::DenseMap<const Decl *, std::pair<const Expr *, llvm::Value *>>
568 llvm::DenseMap<const Decl *, std::pair<const Expr *, llvm::Value *>> VLASizes;
702 const VarDecl *SrcVD, const Expr *Copy) {
747 for (const auto *D : C->varlists())
761 for (const Expr *IInit : C->private_copies()) {
822 const Expr *Init = VD->getInit();
882 for (const Expr *IInit : C->private_copies()) {
913 for (const Expr *AssignOp : C->assignment_ops()) {
977 for (const Expr *C : LoopDirective->counters()) {
990 for (const Expr *IInit : C->private_copies()) {
1048 llvm::DenseMap<const VarDecl *, const Expr *> LoopCountersAndUpdates;
1051 for (const Expr *F : LoopDirective->finals()) {
1065 for (const Expr *AssignOp : C->assignment_ops()) {
1074 if (const Expr *FinalExpr = LoopCountersAndUpdates.lookup(CanonicalVD))
1094 if (const Expr *PostUpdate = C->getPostUpdateExpr())
1106 SmallVector<const Expr *, 4> Shareds;
1107 SmallVector<const Expr *, 4> Privates;
1108 SmallVector<const Expr *, 4> ReductionOps;
1109 SmallVector<const Expr *, 4> LHSs;
1110 SmallVector<const Expr *, 4> RHSs;
1116 for (const Expr *Ref : C->varlists()) {
1133 for (const Expr *IRef : Shareds) {
1209 llvm::SmallVector<const Expr *, 8> Privates;
1210 llvm::SmallVector<const Expr *, 8> LHSExprs;
1211 llvm::SmallVector<const Expr *, 8> RHSExprs;
1212 llvm::SmallVector<const Expr *, 8> ReductionOps;
1241 if (const Expr *PostUpdate = C->getPostUpdateExpr()) {
1290 const Expr *IfCond = nullptr;
1346 for (const Expr *UE : D.updates())
1353 for (const Expr *UE : C->updates())
1361 for (const Expr *E : D.finals_conditions()) {
1394 const Stmt &S, bool RequiresCleanup, const Expr *LoopCond,
1395 const Expr *IncExpr,
1448 for (const Expr *Init : C->inits()) {
1488 for (const Expr *F : C->finals()) {
1510 if (const Expr *PostUpdate = C->getPostUpdateExpr())
1523 if (const Expr *AlignmentExpr = Clause->getAlignment()) {
1528 for (const Expr *E : Clause->varlists()) {
1557 for (const Expr *E : S.counters()) {
1603 const Expr *Cond, llvm::BasicBlock *TrueBlock,
1612 for (const Expr *I : S.inits()) {
1619 for (const Expr * E: S.dependent_counters()) {
1630 for (const Expr *E : S.dependent_inits()) {
1647 for (const Expr *C : LoopDirective->counters()) {
1654 for (const Expr *E : C->varlists()) {
1718 for (const Expr *F : D.finals()) {
1806 const Expr *IVExpr = S.getIterationVariable();
1873 const Expr *IVExpr = S.getIterationVariable();
2036 const Expr *IVExpr = S.getIterationVariable();
2092 const Expr *IVExpr = S.getIterationVariable();
2103 Expr *IncExpr;
2188 const Expr *IVExpr = LS.getIterationVariable();
2313 const OMPLoopDirective &S, Expr *EUB,
2362 llvm::DenseSet<const Expr *> EmittedFinals;
2396 const Expr *ChunkExpr = nullptr;
2415 Expr::EvalResult Result;
2553 const Expr *IVExpr = LS.getIterationVariable();
2772 llvm::SmallVector<const Expr *, 8> CopyprivateVars;
2773 llvm::SmallVector<const Expr *, 8> DestExprs;
2774 llvm::SmallVector<const Expr *, 8> SrcExprs;
2775 llvm::SmallVector<const Expr *, 8> AssignmentOps;
2826 const Expr *Hint = nullptr;
2887 const Expr *Cond = Clause->getCondition();
2899 const Expr *Prio = Clause->getPriority();
2912 for (const Expr *IInit : C->private_copies()) {
2926 for (const Expr *IInit : C->private_copies()) {
2942 for (const Expr *IInit : C->private_copies()) {
2955 SmallVector<const Expr *, 4> LHSs;
2956 SmallVector<const Expr *, 4> RHSs;
2962 for (const Expr *Ref : C->varlists()) {
2978 for (const Expr *IRef : C->varlists())
2998 for (const Expr *E : Data.PrivateVars) {
3005 for (const Expr *E : Data.FirstprivateVars) {
3013 for (const Expr *E : Data.LastprivateVars) {
3070 SmallVector<const Expr *, 4> InRedVars;
3071 SmallVector<const Expr *, 4> InRedPrivs;
3072 SmallVector<const Expr *, 4> InRedOps;
3073 SmallVector<const Expr *, 4> TaskgroupDescriptors;
3078 for (const Expr *Ref : C->varlists()) {
3218 for (const Expr *IRef : C->varlists())
3236 for (const Expr *E : Data.FirstprivateVars) {
3284 const Expr *IfCond = nullptr;
3326 if (const Expr *E = S.getReductionRef()) {
3327 SmallVector<const Expr *, 4> LHSs;
3328 SmallVector<const Expr *, 4> RHSs;
3335 for (const Expr *Ref : C->varlists()) {
3375 Expr *IncExpr) {
3458 if (const Expr *Ch = C->getChunkSize()) {
3505 const Expr *Cond =
3710 const Expr *X, const Expr *V,
3710 const Expr *X, const Expr *V,
3734 const Expr *X, const Expr *E,
3734 const Expr *X, const Expr *E,
3866 const Expr *X, const Expr *E,
3866 const Expr *X, const Expr *E,
3867 const Expr *UE, bool IsXLHSInRHSPart,
3921 bool IsPostfixUpdate, const Expr *V,
3922 const Expr *X, const Expr *E,
3922 const Expr *X, const Expr *E,
3923 const Expr *UE, bool IsXLHSInRHSPart,
4004 const Expr *X, const Expr *V, const Expr *E,
4004 const Expr *X, const Expr *V, const Expr *E,
4004 const Expr *X, const Expr *V, const Expr *E,
4005 const Expr *UE, bool IsXLHSInRHSPart,
4133 const Expr *IfCond = nullptr;
4144 const Expr *Device = nullptr;
4239 const Expr *NumTeams = NT ? NT->getNumTeams() : nullptr;
4240 const Expr *ThreadLimit = TL ? TL->getThreadLimit() : nullptr;
4607 const Expr *IfCond = nullptr;
4639 for (const Expr *PvtVarIt : C.private_copies()) {
4770 const Expr *IfCond = nullptr;
4775 const Expr *Device = nullptr;
4795 const Expr *IfCond = nullptr;
4800 const Expr *Device = nullptr;
4816 const Expr *IfCond = nullptr;
4821 const Expr *Device = nullptr;
4970 const Expr *IfCond = nullptr;
5042 const Expr *IVExpr = S.getIterationVariable();
5159 const Expr *IfCond = nullptr;
5164 const Expr *Device = nullptr;
5182 for (const Expr *E : LD->counters()) {
tools/clang/lib/CodeGen/CGValue.h 224 Expr *BaseIvarExp;
304 Expr *getBaseIvarExp() const { return BaseIvarExp; }
305 void setBaseIvarExp(Expr *V) { BaseIvarExp = V; }
tools/clang/lib/CodeGen/CodeGenFunction.cpp 1329 bool CodeGenFunction::ConstantFoldsToSimpleInteger(const Expr *Cond,
1343 bool CodeGenFunction::ConstantFoldsToSimpleInteger(const Expr *Cond,
1348 Expr::EvalResult Result;
1366 void CodeGenFunction::EmitBranchOnBoolExpr(const Expr *Cond,
1929 if (const Expr *size = vat->getSizeExpr()) {
2000 Address CodeGenFunction::EmitVAListRef(const Expr* E) {
2006 Address CodeGenFunction::EmitMSVAListRef(const Expr *E) {
2060 const Expr *E,
tools/clang/lib/CodeGen/CodeGenFunction.h 1090 static bool shouldBindAsLValue(const Expr *expr) {
1103 const Expr *e) {
1154 static bool shouldBindAsLValue(const Expr *expr) {
1390 llvm::DenseMap<const Expr*, llvm::Value*> VLASizeMap;
1899 void EmitInitializerForField(FieldDecl *Field, LValue LHS, Expr *Init);
2271 llvm::Value *EvaluateExprAsBool(const Expr *E);
2274 void EmitIgnoredExpr(const Expr *E);
2282 RValue EmitAnyExpr(const Expr *E,
2288 Address EmitVAListRef(const Expr *E);
2293 Address EmitMSVAListRef(const Expr *E);
2297 RValue EmitAnyExprToTemp(const Expr *E);
2301 void EmitAnyExprToMem(const Expr *E, Address Location,
2304 void EmitAnyExprToExn(const Expr *E, Address Addr);
2308 void EmitExprAsInit(const Expr *init, const ValueDecl *D, LValue lvalue,
2387 static bool IsWrappedCXXThis(const Expr *E);
2645 void EmitBoundsCheck(const Expr *E, const Expr *Base, llvm::Value *Index,
2645 void EmitBoundsCheck(const Expr *E, const Expr *Base, llvm::Value *Index,
2674 void EmitScalarInit(const Expr *init, const ValueDecl *D, LValue lvalue,
2682 bool isTrivialInitializer(const Expr *Init);
2832 void EmitAlignmentAssumption(llvm::Value *PtrValue, const Expr *E,
3007 const Expr *Copy);
3240 const Stmt &S, bool RequiresCleanup, const Expr *LoopCond,
3241 const Expr *IncExpr,
3256 bool EmitOMPWorksharingLoop(const OMPLoopDirective &S, Expr *EUB,
3262 const CodeGenLoopTy &CodeGenLoop, Expr *IncExpr);
3271 LValue EmitOMPSharedLValue(const Expr *E);
3290 Expr *EUB = nullptr;
3292 Expr *IncExpr = nullptr;
3294 Expr *Init = nullptr;
3296 Expr *Cond = nullptr;
3298 Expr *NextLB = nullptr;
3300 Expr *NextUB = nullptr;
3303 llvm::Value *Chunk = nullptr, Expr *EUB = nullptr,
3304 Expr *IncExpr = nullptr, Expr *Init = nullptr,
3304 Expr *IncExpr = nullptr, Expr *Init = nullptr,
3305 Expr *Cond = nullptr, Expr *NextLB = nullptr,
3305 Expr *Cond = nullptr, Expr *NextLB = nullptr,
3306 Expr *NextUB = nullptr)
3341 RValue EmitUnsupportedRValue(const Expr *E,
3346 LValue EmitUnsupportedLValue(const Expr *E,
3365 LValue EmitLValue(const Expr *E);
3370 LValue EmitCheckedLValue(const Expr *E, TypeCheckKind TCK);
3375 void EmitAtomicInit(Expr *E, LValue lvalue);
3523 Address EmitArrayToPointerDecay(const Expr *Array,
3545 LValue getReferenceLValue(CodeGenFunction &CGF, Expr *refExpr) const {
3559 llvm::Value *emitScalarConstant(const ConstantEmission &Constant, Expr *E);
3613 CGCallee EmitCallee(const Expr *E);
3692 bool IsArrow, const Expr *Base);
3694 Address EmitCXXMemberDataPointerAddress(const Expr *E, Address base,
3793 llvm::Value *EmitObjCCollectionLiteral(const Expr *E,
3851 llvm::Value *EmitObjCThrowOperand(const Expr *expr);
3855 llvm::Value *EmitARCExtendBlockObject(const Expr *expr);
3856 llvm::Value *EmitARCReclaimReturnedObject(const Expr *e,
3858 llvm::Value *EmitARCRetainScalarExpr(const Expr *expr);
3859 llvm::Value *EmitARCRetainAutoreleaseScalarExpr(const Expr *expr);
3860 llvm::Value *EmitARCUnsafeUnretainedScalarExpr(const Expr *expr);
3877 RValue EmitReferenceBindingToExpr(const Expr *E);
3887 llvm::Value *EmitScalarExpr(const Expr *E , bool IgnoreResultAssign = false);
3903 void EmitAggExpr(const Expr *E, AggValueSlot AS);
3907 LValue EmitAggExprToLValue(const Expr *E);
3915 ComplexPairTy EmitComplexExpr(const Expr *E,
3921 void EmitComplexExprIntoLValue(const Expr *E, LValue dest, bool isInit);
3996 void EmitSynthesizedCXXCopyCtor(Address Dest, Address Src, const Expr *Exp);
4048 bool ConstantFoldsToSimpleInteger(const Expr *Cond, bool &Result,
4054 bool ConstantFoldsToSimpleInteger(const Expr *Cond, llvm::APSInt &Result,
4062 void EmitBranchOnBoolExpr(const Expr *Cond, llvm::BasicBlock *TrueBlock,
4094 llvm::Value *EmitCheckedArgForBuiltin(const Expr *E, BuiltinCheckKind Kind);
4145 void EmitCallArg(CallArgList &args, const Expr *E, QualType ArgType);
4187 const Expr *InputExpr, std::string &ConstraintStr);
4199 llvm::Value *evaluateOrEmitBuiltinObjectSize(const Expr *E, unsigned Type,
4207 llvm::Value *emitBuiltinObjectSize(const Expr *E, unsigned Type,
4317 Address EmitPointerWithAlignment(const Expr *Addr,
4324 llvm::Value *LoadPassedObjectSize(const Expr *E, QualType EltTy);
4353 QualType getVarArgType(const Expr *Arg);
tools/clang/lib/CodeGen/CodeGenModule.cpp 3543 const Expr *InitExpr = D->getAnyInitializer(InitDecl);
3877 const Expr *InitExpr = D->getAnyInitializer(InitDecl);
5003 const MaterializeTemporaryExpr *E, const Expr *Init) {
5038 Expr::EvalResult EvalResult;
5141 Expr *Init = CtorInitExp->getInit();
5922 CodeGenModule::createOpenCLIntToSamplerConversion(const Expr *E,
tools/clang/lib/CodeGen/CodeGenModule.h 416 llvm::DenseMap<const Expr*, llvm::Constant *> MaterializedGlobalTemporaryMap;
958 const Expr *Inner);
1348 createOpenCLIntToSamplerConversion(const Expr *E, CodeGenFunction &CGF);
tools/clang/lib/CodeGen/ConstantEmitter.h 73 llvm::Constant *tryEmitForInitializer(const Expr *E, LangAS destAddrSpace,
102 llvm::Constant *emitAbstract(const Expr *E, QualType T);
107 llvm::Constant *tryEmitAbstract(const Expr *E, QualType T);
108 llvm::Constant *tryEmitAbstractForMemory(const Expr *E, QualType T);
130 llvm::Constant *tryEmitPrivate(const Expr *E, QualType T);
131 llvm::Constant *tryEmitPrivateForMemory(const Expr *E, QualType T);
tools/clang/lib/CodeGen/CoverageMappingGen.cpp 1030 if (const Expr *Cond = S->getCond()) {
1163 if (const Expr *RHS = CS->getRHS())
tools/clang/lib/CodeGen/ItaniumCXXABI.cpp 121 const Expr *E,
128 EmitMemberDataPointerAddress(CodeGenFunction &CGF, const Expr *E,
576 CodeGenFunction &CGF, const Expr *E, Address ThisAddr,
787 CodeGenFunction &CGF, const Expr *E, Address Base, llvm::Value *MemPtr,
4220 const Expr *copyExpr = CatchParam.getInit();
tools/clang/lib/CodeGen/MicrosoftCXXABI.cpp 596 llvm::Value *AdjustVirtualBase(CodeGenFunction &CGF, const Expr *E,
650 EmitMemberDataPointerAddress(CodeGenFunction &CGF, const Expr *E,
673 EmitLoadOfMemberFunctionPointer(CodeGenFunction &CGF, const Expr *E,
2978 CodeGenFunction &CGF, const Expr *E, const CXXRecordDecl *RD,
3034 CodeGenFunction &CGF, const Expr *E, Address Base, llvm::Value *MemPtr,
3324 CodeGenFunction &CGF, const Expr *E, Address This,
4273 const Expr *SubExpr = E->getSubExpr();
tools/clang/lib/CodeGen/VarBypassDetector.cpp 43 if (const Expr *Init = VD->getInit())
60 ((isa<Expr>(S) && !isa<StmtExpr>(S)) ? origParentScope
tools/clang/lib/Edit/RewriteObjCFoundationAPI.cpp 66 const Expr *Arg = Msg->getArg(0)->IgnoreParenImpCasts();
109 const Expr *Receiver,
159 const Expr *Rec = Msg->getInstanceReceiver();
171 static bool subscriptOperatorNeedsParens(const Expr *FullExpr);
173 static void maybePutParensOnReceiver(const Expr *Receiver, Commit &commit) {
184 const Expr *Rec = Msg->getInstanceReceiver();
232 const Expr *Rec = Msg->getInstanceReceiver();
266 const Expr *Rec = Msg->getInstanceReceiver();
375 static void objectifyExpr(const Expr *E, Commit &commit);
411 const Expr *SentinelExpr = Msg->getArg(Msg->getNumArgs() - 1);
439 static bool getNSArrayObjects(const Expr *E, const NSAPI &NS,
440 SmallVectorImpl<const Expr *> &Objs) {
471 const Expr *SentinelExpr = Msg->getArg(Msg->getNumArgs() - 1);
528 const Expr *SentinelExpr = Msg->getArg(SentinelIdx);
565 SmallVector<const Expr *, 8> Vals;
569 SmallVector<const Expr *, 8> Keys;
621 SmallVector<const Expr *, 8> Vals;
625 SmallVector<const Expr *, 8> Keys;
659 const Expr *Arg,
757 const Expr *Arg = Msg->getArg(0)->IgnoreParenImpCasts();
765 const Expr *literalE = Arg;
891 static bool subscriptOperatorNeedsParens(const Expr *FullExpr) {
892 const Expr* Expr = FullExpr->IgnoreImpCasts();
913 static bool castOperatorNeedsParens(const Expr *FullExpr) {
914 const Expr* Expr = FullExpr->IgnoreImpCasts();
942 static void objectifyExpr(const Expr *E, Commit &commit) {
967 static bool isEnumConstant(const Expr *E) {
980 const Expr *Arg = Msg->getArg(0);
992 const Expr *OrigArg = Arg->IgnoreImpCasts();
1124 const Expr *Arg = Msg->getArg(0);
1130 const Expr *OrigArg = Arg->IgnoreImpCasts();
1176 const Expr *encodingArg = Msg->getArg(1);
tools/clang/lib/Frontend/Rewrite/RewriteModernObjC.cpp 80 Expr *GlobalConstructionExp;
342 void RewriteObjCQualifiedInterfaceTypes(Expr *E);
413 ArrayRef<Expr *> Args,
417 Expr *SynthMsgSendStretCallExpr(FunctionDecl *MsgSendStretFlavor,
420 SmallVectorImpl<Expr*> &MsgExprs,
476 Stmt *SynthesizeBlockCall(CallExpr *Exp, const Expr* BlockExp);
586 CastKind Kind, Expr *E) {
871 Expr *Zero = IntegerLiteral::Create(*Context,
1419 Expr *Base;
1420 SmallVector<Expr*, 2> Args;
1429 Base = cast<Expr>(RewriteFunctionBodyOrGlobalInitializer(Base));
1434 Expr *Arg = OldMsg->getArg(i);
1437 Arg = cast<Expr>(RewriteFunctionBodyOrGlobalInitializer(Arg));
1506 Expr *Base = nullptr;
1507 SmallVector<Expr*, 1> Args;
1514 Base = cast<Expr>(RewriteFunctionBodyOrGlobalInitializer(Base));
1518 Expr *Arg = OldMsg->getArg(i);
1521 Arg = cast<Expr>(RewriteFunctionBodyOrGlobalInitializer(Arg));
2066 Expr *Replacement = getStringLiteral(StrEncoding);
2079 SmallVector<Expr*, 8> SelExprs;
2090 ArrayRef<Expr *> Args,
2159 void RewriteModernObjC::RewriteObjCQualifiedInterfaceTypes(Expr *E) {
2289 Expr *E = ND->getInit();
2585 Expr *Unop = new (Context)
2600 Expr *FlagExp = IntegerLiteral::Create(*Context,
2626 SmallVector<Expr*, 4> MsgExprs;
2627 SmallVector<Expr*, 4> ClsExprs;
2641 SmallVector<Expr*, 4> SelExprs;
2649 Expr *subExpr = Exp->getSubExpr();
2652 const Expr *SubExpr = ICE->IgnoreParenImpCasts();
2717 SmallVector<Expr*, 16> InitExprs;
2721 Expr *count = IntegerLiteral::Create(*Context,
2727 Expr *NSArrayCallExpr =
2748 SmallVector<Expr*, 32> MsgExprs;
2749 SmallVector<Expr*, 4> ClsExprs;
2764 SmallVector<Expr*, 4> SelExprs;
2776 Expr *cnt = IntegerLiteral::Create(*Context,
2838 SmallVector<Expr*, 16> KeyExprs;
2839 SmallVector<Expr*, 16> ValueExprs;
2844 Expr *count = IntegerLiteral::Create(*Context,
2856 Expr *NSValueCallExpr =
2876 Expr *NSKeyCallExpr = CallExpr::Create(
2890 SmallVector<Expr*, 32> MsgExprs;
2891 SmallVector<Expr*, 4> ClsExprs;
2906 SmallVector<Expr*, 4> SelExprs;
2920 Expr *cnt = IntegerLiteral::Create(*Context,
3085 Expr *RewriteModernObjC::SynthMsgSendStretCallExpr(FunctionDecl *MsgSendStretFlavor,
3088 SmallVectorImpl<Expr*> &MsgExprs,
3222 SmallVector<Expr*, 8> MsgExprs;
3232 SmallVector<Expr*, 4> InitExprs;
3247 SmallVector<Expr*, 8> ClsExprs;
3265 Expr *SuperRep;
3309 SmallVector<Expr*, 8> ClsExprs;
3329 SmallVector<Expr*, 4> InitExprs;
3342 SmallVector<Expr*, 8> ClsExprs;
3360 Expr *SuperRep;
3401 Expr *recExpr = Exp->getInstanceReceiver();
3417 SmallVector<Expr*, 8> SelExprs;
3425 Expr *userExpr = Exp->getArg(i);
3434 const Expr *SubExpr = ICE->IgnoreParenImpCasts();
3542 Expr *STCE = SynthMsgSendStretCallExpr(MsgSendStretFlavor,
4550 Stmt *RewriteModernObjC::SynthesizeBlockCall(CallExpr *Exp, const Expr *BlockExp) {
4566 Expr *LHSExp = CEXPR->getLHS();
4568 Expr *RHSExp = CEXPR->getRHS();
4570 Expr *CONDExp = CEXPR->getCond();
4573 SourceLocation(), cast<Expr>(LHSStmt),
4574 SourceLocation(), cast<Expr>(RHSStmt),
4636 SmallVector<Expr*, 8> BlkExprs;
4703 Expr *Exp = new (Context) UnaryOperator(DRE, UO_Deref, DRE->getType(),
5137 Expr *E = ND->getInit();
5260 Expr *NewRep;
5275 SmallVector<Expr*, 4> InitExprs;
5300 Expr *Exp;
5382 Expr *FlagExp = IntegerLiteral::Create(*Context, llvm::APInt(IntSize, flag),
7439 Expr *BaseExpr = IV->getBase();
7444 BaseExpr = cast<Expr>(RewriteFunctionBodyOrGlobalInitializer(BaseExpr));
7450 Expr *Replacement = IV;
7513 Expr *Zero = IntegerLiteral::Create(*Context,
7539 Expr *Exp = new (Context) UnaryOperator(castExpr, UO_Deref, IvarT,
tools/clang/lib/Frontend/Rewrite/RewriteObjC.cpp 290 void RewriteObjCQualifiedInterfaceTypes(Expr *E);
350 ArrayRef<Expr *> Args,
357 SmallVectorImpl<Expr*> &MsgExprs,
386 Stmt *SynthesizeBlockCall(CallExpr *Exp, const Expr* BlockExp);
492 CastKind Kind, Expr *E) {
1238 Expr *Base, *RHS;
1247 Base = cast<Expr>(RewriteFunctionBodyOrGlobalInitializer(Base));
1253 RHS = cast<Expr>(RewriteFunctionBodyOrGlobalInitializer(RHS));
1320 Expr *Base = nullptr;
1328 Base = cast<Expr>(RewriteFunctionBodyOrGlobalInitializer(Base));
1334 SmallVector<Expr*, 1> Args;
1684 Expr *syncExpr = S->getSynchExpr();
1981 Expr *Replacement = getStringLiteral(StrEncoding);
1994 SmallVector<Expr*, 8> SelExprs;
2005 ArrayRef<Expr *> Args,
2075 void RewriteObjC::RewriteObjCQualifiedInterfaceTypes(Expr *E) {
2201 Expr *E = ND->getInit();
2510 Expr *Unop = new (Context)
2587 SmallVectorImpl<Expr*> &MsgExprs,
2649 SmallVector<Expr*, 8> MsgExprs;
2659 SmallVector<Expr*, 4> InitExprs;
2674 SmallVector<Expr*, 8> ClsExprs;
2694 Expr *SuperRep;
2738 SmallVector<Expr*, 8> ClsExprs;
2755 SmallVector<Expr*, 4> InitExprs;
2768 SmallVector<Expr*, 8> ClsExprs;
2789 Expr *SuperRep;
2830 Expr *recExpr = Exp->getInstanceReceiver();
2846 SmallVector<Expr*, 8> SelExprs;
2854 Expr *userExpr = Exp->getArg(i);
2863 const Expr *SubExpr = ICE->IgnoreParenImpCasts();
3045 Expr *DerefExpr = new (Context) UnaryOperator(DRE, UO_AddrOf,
3718 Stmt *RewriteObjC::SynthesizeBlockCall(CallExpr *Exp, const Expr *BlockExp) {
3734 Expr *LHSExp = CEXPR->getLHS();
3736 Expr *RHSExp = CEXPR->getRHS();
3738 Expr *CONDExp = CEXPR->getCond();
3741 SourceLocation(), cast<Expr>(LHSStmt),
3742 SourceLocation(), cast<Expr>(RHSStmt),
3804 SmallVector<Expr*, 8> BlkExprs;
3872 Expr *Exp = new (Context) UnaryOperator(DRE, UO_Deref, DRE->getType(),
4269 Expr *E = ND->getInit();
4406 Expr *NewRep;
4413 SmallVector<Expr*, 4> InitExprs;
4438 Expr *Exp;
4518 Expr *FlagExp = IntegerLiteral::Create(*Context, llvm::APInt(IntSize, flag),
5792 Expr *BaseExpr = IV->getBase();
5797 BaseExpr = cast<Expr>(RewriteFunctionBodyOrGlobalInitializer(BaseExpr));
5803 Expr *Replacement = IV;
tools/clang/lib/Index/IndexBody.cpp 57 SymbolRoleSet getRolesForRef(const Expr *E,
154 const Expr *E, const Type *T, const DeclarationNameInfo &NameInfo,
235 const auto *E = POE->getSyntacticForm();
326 bool passObjCLiteralMethodCall(const ObjCMethodDecl *MD, const Expr *E) {
390 Expr *Init) {
431 for (Expr *init : SyntaxForm->inits()) {
tools/clang/lib/Index/IndexingContext.cpp 78 const Expr *RefE,
355 const Expr *OrigE,
tools/clang/lib/Index/IndexingContext.h 83 const Expr *RefE = nullptr,
131 const Expr *RefE,
tools/clang/lib/Parse/ParseExpr.cpp 191 Expr *ReceiverExpr) {
1493 if (Expr *PostfixExpr = Res.get()) {
1632 Expr *ExecConfig = nullptr;
1749 Expr* OrigLHS = !LHS.isInvalid() ? LHS.get() : nullptr;
1754 Expr *Base = OrigLHS;
1791 Expr *Base = LHS.get();
1792 Expr *CorrectedBase = CorrectedLHS.get();
2899 bool Parser::ParseExpressionList(SmallVectorImpl<Expr *> &Exprs,
2951 Parser::ParseSimpleExpressionList(SmallVectorImpl<Expr*> &Exprs,
tools/clang/lib/Parse/ParseExprCXX.cpp 1120 Expr *InitExpr = Init.get();
1679 Parser::ParseCXXPseudoDestructor(Expr *Base, SourceLocation OpLoc,
1837 Expr *InitList = Init.get();
3121 SmallVectorImpl<Expr*> &PlacementArgs,
tools/clang/lib/Parse/ParseObjc.cpp 3148 Expr *ReceiverExpr) {
tools/clang/lib/Parse/ParseOpenMP.cpp 51 SmallVector<Expr *, 4> Identifiers;
64 llvm::ArrayRef<Expr *> getIdentifiers() const { return Identifiers; }
685 SmallVectorImpl<Expr *> &Uniforms, SmallVectorImpl<Expr *> &Aligneds,
685 SmallVectorImpl<Expr *> &Uniforms, SmallVectorImpl<Expr *> &Aligneds,
686 SmallVectorImpl<Expr *> &Alignments, SmallVectorImpl<Expr *> &Linears,
686 SmallVectorImpl<Expr *> &Alignments, SmallVectorImpl<Expr *> &Linears,
687 SmallVectorImpl<unsigned> &LinModifiers, SmallVectorImpl<Expr *> &Steps) {
724 SmallVectorImpl<Expr *> *Vars = &Uniforms;
770 SmallVector<Expr *, 4> Uniforms;
771 SmallVector<Expr *, 4> Aligneds;
772 SmallVector<Expr *, 4> Alignments;
773 SmallVector<Expr *, 4> Linears;
775 SmallVector<Expr *, 4> Steps;
1012 Optional<std::pair<FunctionDecl *, Expr *>> DeclVarData =
2553 SmallVectorImpl<Expr *> &Vars,
2829 SmallVector<Expr *, 4> Vars;
tools/clang/lib/Parse/ParseStmtAsm.cpp 545 SmallVector<Expr *, 4> Exprs;
651 Expr *OpExpr = static_cast<Expr *>(OpExprs[i].first);
880 SmallVectorImpl<Expr *> &Constraints,
881 SmallVectorImpl<Expr *> &Exprs) {
tools/clang/lib/Parse/ParseTemplate.cpp 406 Expr *ConstraintExpr = ConstraintExprResult.get();
tools/clang/lib/Sema/AnalysisBasedWarnings.cpp 131 static bool HasMacroID(const Expr *E) {
137 if (const Expr *SubExpr = dyn_cast_or_null<Expr>(SubStmt))
137 if (const Expr *SubExpr = dyn_cast_or_null<Expr>(SubStmt))
735 void VisitExpr(const Expr *E) {
844 const Expr *User = Use.getUser();
997 if (const Expr *Initializer = VD->getInit()) {
1330 Expr::EvalResult Result;
tools/clang/lib/Sema/DeclSpec.cpp 167 Expr *NoexceptExpr,
372 if (Expr *E = DS.getRepAsExpr())
736 Expr *Rep,
tools/clang/lib/Sema/JumpDiagnostics.cpp 172 const Expr *Init = VD->getInit();
234 if (Expr *Init = VD->getInit())
289 unsigned &ParentScope = ((isa<Expr>(S) && !isa<StmtExpr>(S))
546 SmallVector<const Expr *, 4> CommaLHS;
548 const Expr *ExtendedObject =
tools/clang/lib/Sema/ScopeInfo.cpp 99 const Expr *DoubleBase = BaseProp->getBase();
121 const Expr *E = OVE->getSourceExpr();
130 FunctionScopeInfo::WeakObjectProfileTy::WeakObjectProfileTy(const Expr *BaseE,
157 void FunctionScopeInfo::markSafeWeakUse(const Expr *E) {
233 llvm::function_ref<void(VarDecl *, Expr *)> Callback) const {
234 for (Expr *E : PotentiallyCapturingExprs) {
tools/clang/lib/Sema/Sema.cpp 475 void Sema::diagnoseZeroToNullptrConversion(CastKind Kind, const Expr* E) {
503 ExprResult Sema::ImpCastExprToType(Expr *E, QualType Ty,
1671 Expr *VarRef =
1678 Expr *Init = Result.getAs<Expr>();
1678 Expr *Init = Result.getAs<Expr>();
1930 bool Sema::tryExprAsCall(Expr &E, QualType &ZeroArgCallReturnTy,
2087 static bool IsCallableWithAppend(Expr *E) {
2095 static bool IsCPUDispatchCPUSpecificMultiVersion(const Expr *E) {
2299 bool Sema::checkOpenCLDisabledDecl(const NamedDecl &D, const Expr &E) {
tools/clang/lib/Sema/SemaAccess.cpp 1748 Expr *ObjectExpr,
1749 Expr *ArgExpr,
1799 Sema::AccessResult Sema::CheckAddressOfMemberAccess(Expr *OvlExpr,
tools/clang/lib/Sema/SemaAttr.cpp 290 StringRef SlotLabel, Expr *alignment) {
291 Expr *Alignment = static_cast<Expr *>(alignment);
tools/clang/lib/Sema/SemaCUDA.cpp 492 const Expr *Init = VD->getInit();
tools/clang/lib/Sema/SemaCast.cpp 59 ValueKind(Expr::getValueKindForType(destType)),
144 Expr *src = SrcExpr.get();
178 static TryCastResult TryLValueToRValueCast(Sema &Self, Expr *SrcExpr,
183 static TryCastResult TryStaticReferenceDowncast(Sema &Self, Expr *SrcExpr,
238 SourceLocation LParenLoc, Expr *E,
259 TypeSourceInfo *DestTInfo, Expr *E,
348 TypeSourceInfo *TSI, Expr *Operand,
370 SourceRange range, Expr *src,
446 SourceRange opRange, Expr *src, QualType destType,
883 static void DiagnoseReinterpretUpDownCast(Sema &Self, const Expr *SrcExpr,
1287 TryCastResult TryLValueToRValueCast(Sema &Self, Expr *SrcExpr,
1346 TryStaticReferenceDowncast(Sema &Self, Expr *SrcExpr, QualType DestType,
1670 Expr *SrcExprRaw = SrcExpr.get();
1894 Expr *Src = SrcExpr.get()->IgnoreParenImpCasts();
1964 const Expr *SrcExpr, QualType DestType,
1997 Expr *E = Result.get();
2002 Expr::getValueKindForType(DestType) == VK_RValue // Convert Fun to Ptr
2660 Expr::EvalResult Result;
2883 Expr *CastExpr) {
2909 Expr *CastExpr,
2920 auto *SubExpr = Op.SrcExpr.get();
tools/clang/lib/Sema/SemaChecking.cpp 135 Expr *ValArg = TheCall->getArg(0);
144 Expr *StrArg = TheCall->getArg(1)->IgnoreParenCasts();
166 for (Expr *Arg : TheCall->arguments()) {
254 Expr *Builtin = BuiltinCall->getCallee()->IgnoreImpCasts();
255 Expr *Call = BuiltinCall->getArg(0);
256 Expr *Chain = BuiltinCall->getArg(1);
403 Expr::EvalResult Result;
404 Expr *SizeArg = TheCall->getArg(ObjectIndex);
419 Expr *ObjArg = TheCall->getArg(ObjectIndex);
430 Expr::EvalResult Result;
431 Expr *UsedSizeArg = TheCall->getArg(SizeIndex);
477 static inline bool isBlockPointer(Expr *Arg) {
483 static bool checkOpenCLBlockArgs(Sema &S, Expr *BlockArg) {
533 Expr *NDRangeArg = TheCall->getArg(0);
540 Expr *BlockArg = TheCall->getArg(1);
556 Expr *BlockArg = TheCall->getArg(0);
566 static bool checkOpenCLEnqueueIntType(Sema &S, Expr *E,
581 Expr *BlockArg,
638 Expr *Arg0 = TheCall->getArg(0);
639 Expr *Arg1 = TheCall->getArg(1);
640 Expr *Arg2 = TheCall->getArg(2);
641 Expr *Arg3 = TheCall->getArg(3);
693 Expr *Arg6 = TheCall->getArg(6);
710 Expr *Arg4 = TheCall->getArg(4);
711 Expr *Arg5 = TheCall->getArg(5);
715 Expr::NPC_ValueDependentIsNotNull) &&
726 Expr::NPC_ValueDependentIsNotNull) &&
755 const Expr *Arg0 = Call->getArg(0);
805 const Expr *Arg0 = Call->getArg(0);
806 const Expr *ArgIdx = Call->getArg(Idx);
855 const Expr *Arg2 = Call->getArg(2);
1377 const Expr *PtrArg = TheCall->getArg(0)->IgnoreParenImpCasts();
1388 const Expr *FnPtrArg = TheCall->getArg(1)->IgnoreImpCasts();
1680 Expr *Arg = TheCall->getArg(PtrArgNum);
1754 Expr *PointerArg = TheCall->getArg(IsLdrex ? 0 : 1);
1970 Expr *Arg = TheCall->getArg(0);
3303 Expr *Arg = TheCall->getArg(0);
3369 Expr *Arg = TheCall->getArg(0);
3389 Expr *Arg = TheCall->getArg(0);
3588 Expr *Arg = TheCall->getArg(ArgNum);
3698 Expr *Arg = TheCall->getArg(ArgNum);
4110 static bool CheckNonNullExpr(Sema &S, const Expr *Expr) {
4136 const Expr *ArgExpr,
4159 Expr **Args,
4177 const Expr *FormatExpr = Args[Idx];
4207 ArrayRef<const Expr *> Args,
4221 for (const auto *Arg : Args)
4305 const Expr *ThisArg, ArrayRef<const Expr *> Args,
4305 const Expr *ThisArg, ArrayRef<const Expr *> Args,
4338 if (const Expr *Arg = Args[ArgIdx]) {
4362 ArrayRef<const Expr *> Args,
4381 Expr** Args = TheCall->getArgs();
4384 Expr *ImplicitThis = nullptr;
4428 ArrayRef<const Expr *> Args) {
4687 Expr *Ptr = Args[0];
4807 SmallVector<Expr *, 5> APIOrderedArgs;
4877 Expr *ValArg = APIOrderedArgs[i];
4917 SmallVector<Expr*, 5> SubExprs;
4965 auto *Scope = Args[Args.size() - 1];
5026 Expr *Callee = TheCall->getCallee();
5042 Expr *FirstArg = TheCall->getArg(0);
5411 Expr *PointerArg = TheCall->getArg(numArgs - 1);
5461 bool Sema::CheckObjCString(Expr *Arg) {
5491 ExprResult Sema::CheckOSLogFormatStringArg(Expr *Arg) {
5516 static bool checkVAStartABI(Sema &S, unsigned BuiltinID, Expr *Fn) {
5550 static bool checkVAStartIsInVariadicFunction(Sema &S, Expr *Fn,
5592 Expr *Fn = TheCall->getCallee();
5625 const Expr *Arg = TheCall->getArg(1)->IgnoreParenCasts();
5674 Expr *Func = Call->getCallee();
5691 const Expr *Arg1 = Call->getArg(1)->IgnoreParens();
5694 const Expr *Arg2 = Call->getArg(2)->IgnoreParens();
5776 Expr *OrigArg = TheCall->getArg(NumArgs-1);
5792 Expr *CastArg = Cast->getSubExpr();
5943 SmallVector<Expr*, 32> exprs;
5956 ExprResult Sema::SemaConvertVectorExpr(Expr *E, TypeSourceInfo *TInfo,
6009 Expr *Arg = TheCall->getArg(0);
6025 Expr *Arg = TheCall->getArg(1);
6065 Expr *Arg = TheCall->getArg(1);
6159 ArrayRef<const Expr *> Args(TheCall->getArgs(), TheCall->getNumArgs());
6180 Expr *Arg = TheCall->getArg(ArgNum);
6202 Expr *Arg = TheCall->getArg(ArgNum);
6233 Expr *Arg = TheCall->getArg(ArgNum);
6254 Expr *Arg = TheCall->getArg(ArgNum);
6300 Expr *Arg = TheCall->getArg(ArgNum);
6325 Expr *Arg = TheCall->getArg(ArgNum);
6348 Expr *Arg0 = TheCall->getArg(0);
6349 Expr *Arg1 = TheCall->getArg(1);
6377 Expr *Arg0 = TheCall->getArg(0);
6397 Expr *Arg0 = TheCall->getArg(0);
6398 Expr *Arg1 = TheCall->getArg(1);
6420 Expr *Arg0 = TheCall->getArg(0);
6438 Expr *ArgA = TheCall->getArg(0);
6439 Expr *ArgB = TheCall->getArg(1);
6452 Context, Expr::NPC_ValueDependentIsNotNull); };
6517 Expr *Arg = TheCall->getArg(ArgNum);
6605 Expr *Arg = TheCall->getArg(1);
6634 SmallVector<const Expr *, 4> DiagnosticExprs;
6655 void Update(signed NewFirstUncoveredArg, const Expr *StrExpr) {
6673 void Diagnose(Sema &S, bool IsFunctionCall, const Expr *ArgExpr);
6778 const Expr *OrigFormatExpr,
6779 ArrayRef<const Expr *> Args,
6794 checkFormatStringExpr(Sema &S, const Expr *E, ArrayRef<const Expr *> Args,
6794 checkFormatStringExpr(Sema &S, const Expr *E, ArrayRef<const Expr *> Args,
6812 if (E->isNullPointerConstant(S.Context, Expr::NPC_ValueDependentIsNotNull))
6872 if (const Expr *src = cast<OpaqueValueExpr>(E)->getSourceExpr()) {
6905 if (const Expr *Init = VD->getAnyInitializer()) {
6963 const Expr *Arg = CE->getArg(FA->getFormatIdx().getASTIndex());
6980 const Expr *Arg = CE->getArg(0);
7012 const Expr *Arg = ME->getArg(FA->getFormatIdx().getASTIndex());
7052 Expr::EvalResult LResult, RResult;
7055 LResult, S.Context, Expr::SE_NoSideEffects, S.isConstantEvaluated());
7057 RResult, S.Context, Expr::SE_NoSideEffects, S.isConstantEvaluated());
7082 Expr::EvalResult IndexResult;
7084 Expr::SE_NoSideEffects,
7119 ArrayRef<const Expr *> Args,
7132 bool Sema::CheckFormatArguments(ArrayRef<const Expr *> Args,
7144 const Expr *OrigFormatExpr = Args[format_idx]->IgnoreParenCasts();
7222 const Expr *OrigFormatExpr;
7228 ArrayRef<const Expr *> Args;
7240 const Expr *origFormatExpr,
7243 ArrayRef<const Expr *> Args, unsigned formatIdx,
7287 EmitFormatDiagnostic(Sema &S, bool inFunctionCall, const Expr *ArgumentExpr,
7307 const Expr *getDataArg(unsigned i) const;
7478 const Expr *CheckFormatHandler::getDataArg(unsigned i) const {
7499 const Expr *ArgExpr) {
7651 Sema &S, bool InFunctionCall, const Expr *ArgumentExpr,
7678 const Expr *origFormatExpr,
7681 bool hasVAListArg, ArrayRef<const Expr *> Args,
7712 const Expr *E);
7728 const Expr *E);
7784 const Expr *Arg = getDataArg(argIndex);
7929 bool Sema::hasCStrMethod(const Expr *E) {
7945 const analyze_printf::ArgType &AT, const Expr *E) {
8027 const Expr *Ex = getDataArg(argIndex);
8167 const Expr *Arg = getDataArg(argIndex);
8174 static bool requiresParensToAddCast(const Expr *E) {
8178 const Expr *Inside = E->IgnoreImpCasts();
8213 const Expr *E) {
8294 const Expr *E) {
8592 const Expr *origFormatExpr, Sema::FormatStringType type,
8595 ArrayRef<const Expr *> Args, unsigned formatIdx,
8711 const Expr *Ex = getDataArg(argIndex);
8762 const Expr *OrigFormatExpr,
8763 ArrayRef<const Expr *> Args,
9276 const Expr *FirstArg = Call->getArg(0);
9277 const Expr *SecondArg = Call->getArg(1);
9313 static bool CheckMemorySizeofForComparison(Sema &S, const Expr *E,
9372 static const UnaryExprOrTypeTraitExpr *getAsSizeOfExpr(const Expr *E) {
9381 static const Expr *getSizeOfExprArg(const Expr *E) {
9381 static const Expr *getSizeOfExprArg(const Expr *E) {
9389 static QualType getSizeOfArgType(const Expr *E) {
9402 SearchNonTrivialToInitializeField(const Expr *E, Sema &S) : E(E), S(S) {}
9430 static void diag(QualType RT, const Expr *E, Sema &S) {
9436 const Expr *E;
9444 SearchNonTrivialToCopyField(const Expr *E, Sema &S) : E(E), S(S) {}
9475 static void diag(QualType RT, const Expr *E, Sema &S) {
9481 const Expr *E;
9488 static bool doesExprLikelyComputeSize(const Expr *SizeofExpr) {
9528 const Expr *SizeArg =
9593 const Expr *LenExpr = Call->getArg(LenArg)->IgnoreParenImpCasts();
9604 const Expr *SizeOfArg = getSizeOfExprArg(LenExpr);
9615 const Expr *Dest = Call->getArg(ArgIdx)->IgnoreParenImpCasts();
9768 static const Expr *ignoreLiteralAdditions(const Expr *Ex, ASTContext &Ctx) {
9768 static const Expr *ignoreLiteralAdditions(const Expr *Ex, ASTContext &Ctx) {
9776 const Expr *RHS = BO->getRHS()->IgnoreParenCasts();
9777 const Expr *LHS = BO->getLHS()->IgnoreParenCasts();
9813 const Expr *SrcArg = ignoreLiteralAdditions(Call->getArg(1), Context);
9814 const Expr *SizeArg = ignoreLiteralAdditions(Call->getArg(2), Context);
9815 const Expr *CompareWithSrc = nullptr;
9822 if (const Expr *Ex = getSizeOfExprArg(SizeArg))
9849 const Expr *OriginalSizeArg = Call->getArg(2);
9857 const Expr *DstArg = Call->getArg(0)->IgnoreParenImpCasts();
9873 static bool referToTheSameDecl(const Expr *E1, const Expr *E2) {
9873 static bool referToTheSameDecl(const Expr *E1, const Expr *E2) {
9880 static const Expr *getStrlenExprArg(const Expr *E) {
9880 static const Expr *getStrlenExprArg(const Expr *E) {
9898 const Expr *DstArg = CE->getArg(0)->IgnoreParenCasts();
9899 const Expr *SrcArg = CE->getArg(1)->IgnoreParenCasts();
9900 const Expr *LenArg = CE->getArg(2)->IgnoreParenCasts();
9909 if (const Expr *SizeOfArg = getSizeOfExprArg(LenArg)) {
9918 const Expr *L = BE->getLHS()->IgnoreParenCasts();
9919 const Expr *R = BE->getRHS()->IgnoreParenCasts();
9976 Sema::CheckReturnValExpr(Expr *RetValExp, QualType lhsType,
10011 void Sema::CheckFloatComparison(SourceLocation Loc, Expr* LHS, Expr *RHS) {
10011 void Sema::CheckFloatComparison(SourceLocation Loc, Expr* LHS, Expr *RHS) {
10012 Expr* LeftExprSansParen = LHS->IgnoreParenImpCasts();
10013 Expr* RightExprSansParen = RHS->IgnoreParenImpCasts();
10198 static QualType GetExprType(const Expr *E) {
10209 static IntRange GetExprRange(ASTContext &C, const Expr *E, unsigned MaxWidth,
10214 Expr::EvalResult result;
10433 static IntRange GetExprRange(ASTContext &C, const Expr *E,
10476 static void AnalyzeImplicitConversions(Sema &S, Expr *E, SourceLocation CC,
10479 static bool IsEnumConstOrFromMacro(Sema &S, Expr *E) {
10500 static bool isKnownToHaveUnsignedValue(Expr *E) {
10631 static bool HasEnumType(Expr *E) {
10643 static int classifyConstantValue(Expr *Constant) {
10658 Expr *Constant, Expr *Other,
10658 Expr *Constant, Expr *Other,
10664 Expr *OriginalOther = Other;
10794 Expr *LHS = E->getLHS();
10795 Expr *RHS = E->getRHS();
10812 Expr *Const = RhsConstant ? RHS : LHS;
10813 Expr *Other = RhsConstant ? LHS : RHS;
10845 Expr *signedOperand, *unsignedOperand;
10897 static bool AnalyzeBitFieldAssignment(Sema &S, FieldDecl *Bitfield, Expr *Init,
10932 Expr *OriginalInit = Init->IgnoreParenImpCasts();
10935 Expr::EvalResult Result;
10937 Expr::SE_AllowSideEffects)) {
10981 Expr *WidthExpr = Bitfield->getBitWidth();
11053 static void DiagnoseImpCast(Sema &S, Expr *E, QualType SourceType, QualType T,
11068 static void DiagnoseImpCast(Sema &S, Expr *E, QualType T,
11080 Sema &S, Expr *SourceExpr, const Sema::SemaDiagnosticBuilder &Builder) {
11081 Expr *Ignored = SourceExpr->IgnoreImplicit();
11095 static void DiagnoseFloatingImpCast(Sema &S, Expr *E, QualType T,
11100 Expr *InnerE = E->IgnoreParenImpCasts();
11111 E->EvaluateAsFloat(Value, S.Context, Expr::SE_AllowSideEffects);
11258 static bool IsImplicitBoolFloatConversion(Sema &S, Expr *Ex, bool ToBool) {
11262 Expr *InnerE = Ex->IgnoreParenImpCasts();
11281 Expr *CurrA = TheCall->getArg(i);
11298 static void DiagnoseNullConversion(Sema &S, Expr *E, QualType T,
11309 const Expr::NullPointerConstantKind NullKind =
11310 E->isNullPointerConstant(S.Context, Expr::NPC_ValueDependentIsNotNull);
11311 if (NullKind != Expr::NPCK_GNUNull && NullKind != Expr::NPCK_CXX11_nullptr)
11311 if (NullKind != Expr::NPCK_GNUNull && NullKind != Expr::NPCK_CXX11_nullptr)
11328 if (NullKind == Expr::NPCK_GNUNull && Loc.isMacroID()) {
11340 << (NullKind == Expr::NPCK_CXX11_nullptr) << T << SourceRange(CC)
11356 Expr *Element,
11443 static bool isSameWidthConstantConversion(Sema &S, Expr *E, QualType T,
11467 static const IntegerLiteral *getIntegerLiteral(Expr *E) {
11480 Expr *LHS, Expr *RHS) {
11480 Expr *LHS, Expr *RHS) {
11505 static void DiagnoseIntInBoolContext(Sema &S, Expr *E) {
11511 Expr::EvalResult Result;
11520 E->EvaluateAsInt(Result, S.Context, Expr::SE_AllowSideEffects))
11542 static void CheckImplicitConversion(Sema &S, Expr *E, QualType T,
11581 S.DiagnoseAlwaysNonNullPointer(E, Expr::NPCK_NotNull, /*IsEqual*/ false,
11590 Expr::EvalResult Result;
11592 Expr::SE_AllowSideEffects)) {
11659 Expr::EvalResult result;
11705 Expr *LastA = CEx->getArg(NumArgs - 1);
11706 Expr *InnerE = LastA->IgnoreParenImpCasts();
11721 Expr::EvalResult Result;
11722 if (E->EvaluateAsFixedPoint(Result, S.Context, Expr::SE_AllowSideEffects,
11737 Expr::EvalResult Result;
11740 Expr::SE_AllowSideEffects)) {
11760 Expr::EvalResult Result;
11762 E->EvaluateAsInt(Result, S.Context, Expr::SE_AllowSideEffects)) {
11858 Expr::EvalResult Result;
11859 if (E->EvaluateAsInt(Result, S.Context, Expr::SE_AllowSideEffects,
11907 Expr::EvalResult Result;
11908 if (E->EvaluateAsInt(Result, S.Context, Expr::SE_AllowSideEffects) &&
11977 static void CheckConditionalOperand(Sema &S, Expr *E, QualType T,
12024 static void CheckBoolLikeConversion(Sema &S, Expr *E, SourceLocation CC) {
12035 static void AnalyzeImplicitConversions(Sema &S, Expr *OrigE, SourceLocation CC,
12038 Expr *E = OrigE->IgnoreParenImpCasts();
12080 for (auto *SE : POE->semantics())
12120 Expr *ChildExpr = dyn_cast_or_null<Expr>(SubStmt);
12120 Expr *ChildExpr = dyn_cast_or_null<Expr>(SubStmt);
12133 Expr *SubExpr = BO->getLHS()->IgnoreParenImpCasts();
12154 static bool checkOpenCLEnqueueIntType(Sema &S, Expr *E, const QualType &IntT) {
12170 static bool CheckForReference(Sema &SemaRef, const Expr *E,
12222 void Sema::DiagnoseAlwaysNonNullPointer(Expr *E,
12223 Expr::NullPointerConstantKind NullKind,
12237 const bool IsCompare = NullKind != Expr::NPCK_NotNull;
12389 if (NullKind == Expr::NPCK_ZeroExpression ||
12390 NullKind == Expr::NPCK_ZeroLiteral) {
12414 void Sema::CheckImplicitConversions(Expr *E, SourceLocation CC) {
12434 void Sema::CheckBoolLikeConversion(Expr *E, SourceLocation CC) {
12440 void Sema::CheckForIntOverflow (Expr *E) {
12442 SmallVector<Expr *, 2> Exprs(1, E);
12445 Expr *OriginalE = Exprs.pop_back_val();
12446 Expr *E = OriginalE->IgnoreParenCasts();
12559 Expr *Use;
12592 SmallVectorImpl<Expr *> &WorkList;
12637 bool evaluate(const Expr *E, bool &Result) {
12653 Object getObject(Expr *E, bool Mod) const {
12674 void addUsage(UsageInfo &UI, Object O, Expr *Ref, UsageKind UK) {
12685 void checkUsage(Object O, UsageInfo &UI, Expr *Ref, UsageKind OtherKind,
12694 Expr *Mod = U.Use;
12695 Expr *ModOrUse = Ref;
12707 void notePreUse(Object O, Expr *Use) {
12713 void notePostUse(Object O, Expr *Use) {
12719 void notePreMod(Object O, Expr *Mod) {
12726 void notePostMod(Object O, Expr *Use, UsageKind UK) {
12733 SequenceChecker(Sema &S, Expr *E, SmallVectorImpl<Expr *> &WorkList)
12733 SequenceChecker(Sema &S, Expr *E, SmallVectorImpl<Expr *> &WorkList)
12742 void VisitExpr(Expr *E) {
12759 void VisitSequencedExpressions(Expr *SequencedBefore, Expr *SequencedAfter) {
12759 void VisitSequencedExpressions(Expr *SequencedBefore, Expr *SequencedAfter) {
12967 Expr *E = ILE->getInit(I);
12983 void Sema::CheckUnsequencedOperations(Expr *E) {
12984 SmallVector<Expr *, 8> WorkList;
12987 Expr *Item = WorkList.pop_back_val();
12992 void Sema::CheckCompletedExpr(Expr *E, SourceLocation CheckLoc,
13006 Expr *Init) {
13121 static CharUnits getDeclAlign(Expr *E, CharUnits TypeAlign,
13134 void Sema::CheckCastAlign(Expr *Op, QualType T, SourceRange TRange) {
13209 const Expr *SizeExpr = dyn_cast<IntegerLiteral>(CTL.getSizeExpr());
13231 void Sema::CheckArrayAccess(const Expr *BaseExpr, const Expr *IndexExpr,
13231 void Sema::CheckArrayAccess(const Expr *BaseExpr, const Expr *IndexExpr,
13255 Expr::EvalResult Result;
13256 if (!IndexExpr->EvaluateAsInt(Result, Context, Expr::SE_AllowSideEffects))
13369 void Sema::CheckArrayAccess(const Expr *expr) {
13410 if (const Expr *lhs = cond->getLHS())
13412 if (const Expr *rhs = cond->getRHS())
13418 for (const auto *Arg : OCE->arguments())
13440 void setLocsFrom(Expr *e) {
13450 static bool considerVariable(VarDecl *var, Expr *ref, RetainCycleOwner &owner) {
13463 static bool findRetainCycleOwner(Sema &S, Expr *e, RetainCycleOwner &owner) {
13547 Expr *Capturer = nullptr;
13581 Expr *LHS = BinOp->getLHS();
13585 if (Expr *RHS = BinOp->getRHS()) {
13599 static Expr *findCapturingExpr(Sema &S, Expr *e, RetainCycleOwner &owner) {
13599 static Expr *findCapturingExpr(Sema &S, Expr *e, RetainCycleOwner &owner) {
13634 static void diagnoseRetainCycle(Sema &S, Expr *capturer,
13783 Expr *Arg = Message->getArg(ArgIndex)->IgnoreImpCasts();
13797 Expr *Receiver = Message->getInstanceReceiver()->IgnoreImpCasts();
13854 if (Expr *capturer = findCapturingExpr(*this, msg->getArg(i), owner)) {
13864 void Sema::checkRetainCycles(Expr *receiver, Expr *argument) {
13864 void Sema::checkRetainCycles(Expr *receiver, Expr *argument) {
13869 if (Expr *capturer = findCapturingExpr(*this, argument, owner))
13873 void Sema::checkRetainCycles(VarDecl *Var, Expr *Init) {
13883 if (Expr *Capturer = findCapturingExpr(*this, Init, Owner))
13888 Expr *RHS, bool isProperty) {
13910 Expr *RHS, bool isProperty) {
13931 QualType LHS, Expr *RHS) {
13944 Expr *LHS, Expr *RHS) {
13944 Expr *LHS, Expr *RHS) {
14129 void Sema::DiagnoseSelfMove(const Expr *LHSExpr, const Expr *RHSExpr,
14129 void Sema::DiagnoseSelfMove(const Expr *LHSExpr, const Expr *RHSExpr,
14174 const Expr *LHSBase = LHSExpr;
14175 const Expr *RHSBase = RHSExpr;
14379 static bool FindTypeTagExpr(const Expr *TypeExpr, const ASTContext &Ctx,
14461 const IdentifierInfo *ArgumentKind, const Expr *TypeExpr,
14536 const ArrayRef<const Expr *> ExprArgs,
14548 const Expr *TypeTagExpr = ExprArgs[TypeTagIdxAST];
14568 const Expr *ArgumentExpr = ExprArgs[ArgumentIdxAST];
14585 Expr::NPC_ValueDependentIsNotNull)) {
14629 void Sema::AddPotentialMisalignedMembers(Expr *E, RecordDecl *RD, ValueDecl *MD,
14647 void Sema::DiscardMisalignedMemberAddress(const Type *T, Expr *E) {
14653 auto *Op = cast<UnaryOperator>(E)->getSubExpr()->IgnoreParens();
14667 Expr *E,
14668 llvm::function_ref<void(Expr *, RecordDecl *, FieldDecl *, CharUnits)>
14710 const Expr *TopBase = TopME->getBase()->IgnoreParenImpCasts();
14775 void Sema::CheckAddressOfPackedMember(Expr *rhs) {
tools/clang/lib/Sema/SemaCodeComplete.cpp 409 static QualType getPreferredTypeOfBinaryRHS(Sema &S, Expr *LHS,
519 void PreferredTypeBuilder::enterBinary(Sema &S, SourceLocation Tok, Expr *LHS,
527 Expr *Base) {
547 Expr *LHS) {
4695 void Sema::CodeCompleteMemberReferenceExpr(Scope *S, Expr *Base,
4696 Expr *OtherOpBase,
4995 Expr *CaseVal = Case->getLHS()->IgnoreParenCasts();
5035 static bool anyNullArguments(ArrayRef<Expr *> Args) {
5104 QualType Sema::ProduceCallSignatureHelp(Scope *S, Expr *Fn,
5105 ArrayRef<Expr *> Args,
5113 Expr::hasAnyTypeDependentArguments(Args)) {
5123 Expr *NakedFn = Fn->IgnoreParenCasts();
5135 SmallVector<Expr *, 12> ArgExprs(
5170 SmallVector<Expr *, 12> ArgExprs(1, NakedFn);
5202 ArrayRef<Expr *> Args,
5241 ArrayRef<Expr *> ArgExprs, IdentifierInfo *II, SourceLocation OpenParLoc) {
6412 static ObjCInterfaceDecl *GetAssumedMessageSendExprType(Expr *E) {
6838 void Sema::CodeCompleteObjCInstanceMessage(Scope *S, Expr *Receiver,
6844 Expr *RecExpr = static_cast<Expr *>(Receiver);
tools/clang/lib/Sema/SemaConcept.cpp 22 bool Sema::CheckConstraintExpression(Expr *ConstraintExpression) {
52 Expr *ConstraintExpr,
109 Expr::EvalResult EvalResult;
tools/clang/lib/Sema/SemaCoroutine.cpp 265 Expr *CoawaitOp = UnresolvedLookupExpr::Create(
276 Expr *E,
284 SourceLocation Loc, Expr *E) {
292 static Expr *buildBuiltinCall(Sema &S, SourceLocation Loc, Builtin::ID Id,
327 Expr *FramePtr =
341 Expr *Results[3];
346 static ExprResult buildMemberCall(Sema &S, Expr *Base, SourceLocation Loc,
375 static Expr *maybeTailCall(Sema &S, QualType RetType, Expr *E,
375 static Expr *maybeTailCall(Sema &S, QualType RetType, Expr *E,
391 Expr *JustAddress = AddressExpr.get();
400 SourceLocation Loc, Expr *E) {
410 Expr *CoroHandle = CoroHandleRes.get();
448 if (Expr *TailCallSuspend = maybeTailCall(S, RetType, AwaitSuspend, Loc))
506 llvm::SmallVector<Expr *, 4> CtorArgExprs;
544 Expr *PLE = ParenListExpr::Create(Context, FD->getLocation(),
692 ExprResult Sema::ActOnCoawaitExpr(Scope *S, SourceLocation Loc, Expr *E) {
712 ExprResult Sema::BuildUnresolvedCoawaitExpr(SourceLocation Loc, Expr *E,
727 Expr *Res =
750 ExprResult Sema::BuildResolvedCoawaitExpr(SourceLocation Loc, Expr *E,
763 Expr *Res = new (Context)
784 Expr *Res =
791 ExprResult Sema::ActOnCoyieldExpr(Scope *S, SourceLocation Loc, Expr *E) {
812 ExprResult Sema::BuildCoyieldExpr(SourceLocation Loc, Expr *E) {
824 Expr *Res = new (Context) CoyieldExpr(Loc, Context.DependentTy, E);
839 Expr *Res =
846 StmtResult Sema::ActOnCoreturnStmt(Scope *S, SourceLocation Loc, Expr *E) {
854 StmtResult Sema::BuildCoreturnStmt(SourceLocation Loc, Expr *E,
894 Expr *PCE = ActOnFinishFullExpr(PC.get(), /*DiscardedValue*/ false).get();
901 static Expr *buildStdNoThrowDeclRef(Sema &S, SourceLocation Loc) {
1045 this->InitialSuspend = cast<Expr>(Fn.CoroutineSuspends.first);
1046 this->FinalSuspend = cast<Expr>(Fn.CoroutineSuspends.second);
1050 static bool diagReturnOnAllocFailure(Sema &S, Expr *E,
1139 SmallVector<Expr *, 1> PlacementArgs;
1215 auto *StdNoThrow = buildStdNoThrowDeclRef(S, Loc);
1244 Expr *FramePtr =
1247 Expr *FrameSize =
1257 SmallVector<Expr *, 2> NewArgs(1, FrameSize);
1276 Expr *CoroFree =
1279 SmallVector<Expr *, 2> DeleteArgs{CoroFree};
1405 static void noteMemberDeclaredHere(Sema &S, Expr *E, FunctionScopeInfo &Fn) {
1497 static Expr *castForMoving(Sema &S, Expr *E, QualType T = QualType()) {
1497 static Expr *castForMoving(Sema &S, Expr *E, QualType T = QualType()) {
1542 Expr *CExpr = nullptr;
tools/clang/lib/Sema/SemaDecl.cpp 1793 if (const Expr *Init = VD->getInit()) {
5348 Expr *E = DS.getRepAsExpr();
5773 Expr::EvalResult Result;
6977 if (Expr *E = (Expr*)D.getAsmLabel()) {
7395 void Sema::CheckShadowingDeclModification(Expr *E, SourceLocation Loc) {
8921 if (Expr *E = (Expr*) D.getAsmLabel()) {
10751 bool Sema::CheckForConstantInitializer(Expr *Init, QualType DclT) {
10760 const Expr *Culprit;
10801 void CheckExpr(Expr *E) {
10812 CheckExpr(cast<Expr>(Child));
10822 Expr *Base = E;
10872 void HandleValue(Expr *E) {
10913 Expr *Base = E->IgnoreParenImpCasts();
10957 Expr *Base = E->getBase()->IgnoreParenImpCasts();
10976 Expr *Callee = E->getCallee();
11007 Expr *ArgExpr = E->getArg(0);
11073 static void CheckSelfReference(Sema &S, Decl* OrigDecl, Expr *E,
11113 Expr *Init) {
11138 ArrayRef<Expr*> DeduceInits;
11153 SmallVector<Expr*, 8> InitsCopy(DeduceInits.begin(), DeduceInits.end());
11182 Expr *DeduceInit = DeduceInits[0];
11246 Expr *Init) {
11275 void Sema::checkNonTrivialCUnionInInitializer(const Expr *Init,
11548 void Sema::AddInitializerToDecl(Decl *RealDecl, Expr *Init, bool DirectInit) {
11724 Init = Result.getAs<Expr>();
11814 const Expr *Culprit;
12401 const Expr *CacheCulprit = nullptr;
12482 Expr *Init = var->getInit();
12769 const Expr *MagicValueExpr = VD->getInit();
15771 Expr *BitWidth, bool *ZeroWidth) {
15862 Declarator &D, Expr *BitfieldWidth) {
15873 Declarator &D, Expr *BitWidth,
15979 bool Mutable, Expr *BitWidth,
16254 Declarator &D, Expr *BitfieldWidth,
16258 Expr *BitWidth = (Expr*)BitfieldWidth;
16388 Expr * BW = IntegerLiteral::Create(Context, Zero, Context.IntTy, DeclLoc);
16898 Expr *Val) {
17099 SourceLocation EqualLoc, Expr *Val) {
17175 Expr *InitExpr = ECD->getInitExpr();
17583 Decl *Sema::ActOnFileScopeAsmDecl(Expr *expr,
tools/clang/lib/Sema/SemaDeclAttr.cpp 241 static bool checkUInt32Argument(Sema &S, const AttrInfo &AI, const Expr *Expr,
277 static bool checkPositiveIntArgument(Sema &S, const AttrInfo &AI, const Expr *Expr,
325 const Expr *IdxExpr, ParamIdx &Idx, bool CanIndexImplicitThis = false) {
384 Expr *ArgExpr = AL.getArgAsExpr(ArgNum);
457 static bool isIntOrBool(Expr *Exp) {
599 static bool isCapabilityExpr(Sema &S, const Expr *Ex) {
631 SmallVectorImpl<Expr *> &Args,
654 Expr *ArgExp = AL.getArgAsExpr(Idx);
734 Expr *&Arg) {
735 SmallVector<Expr *, 1> Args;
748 Expr *Arg = nullptr;
756 Expr *Arg = nullptr;
767 SmallVectorImpl<Expr *> &Args) {
787 SmallVector<Expr *, 1> Args;
791 Expr **StartArg = &Args[0];
797 SmallVector<Expr *, 1> Args;
801 Expr **StartArg = &Args[0];
807 SmallVectorImpl<Expr *> &Args) {
816 SmallVector<Expr *, 1> Args;
821 Expr **StartArg = Size == 0 ? nullptr : &Args[0];
828 SmallVector<Expr *, 1> Args;
833 Expr **StartArg = Size == 0 ? nullptr : &Args[0];
847 Expr *AttrArg = AI.getArgAsExpr(AttrArgNo);
874 const Expr *SizeExpr = AL.getArgAsExpr(0);
885 const Expr *NumberExpr = AL.getArgAsExpr(1);
900 SmallVectorImpl<Expr *> &Args) {
918 SmallVector<Expr*, 2> Args;
928 SmallVector<Expr*, 2> Args;
938 SmallVector<Expr*, 1> Args;
952 SmallVector<Expr*, 1> Args;
957 Expr **StartArg = &Args[0];
964 Expr *&Cond, StringRef &Msg) {
981 !Expr::isPotentialConstantExprUnevaluated(Cond, cast<FunctionDecl>(D),
994 Expr *Cond;
1022 bool referencesArgs(Expr *E) {
1049 Expr *Cond;
1078 Expr *E = AL.getArgAsExpr(0);
1450 Expr *Ex = AL.getArgAsExpr(I);
1536 Expr *E = AL.getArgAsExpr(0),
1545 void Sema::AddAssumeAlignedAttr(Decl *D, const AttributeCommonInfo &CI, Expr *E,
1546 Expr *OE) {
1596 Expr *ParamExpr) {
1682 Expr *Ex = AL.getArgAsExpr(i);
2640 Expr *E = AL.getArgAsExpr(0);
2660 Expr *E = AL.getArgAsExpr(1);
2788 const Expr *E = AL.getArgAsExpr(i);
2812 const Expr *E = AL.getArgAsExpr(0);
3009 Expr *E = AL.getArgAsExpr(0);
3026 Expr *E = AL.getArgAsExpr(0);
3103 Expr *IdxExpr = AL.getArgAsExpr(0);
3187 Expr *E = AL.getArgAsExpr(0);
3257 Expr *IdxExpr = AL.getArgAsExpr(1);
3309 Expr *FirstArgExpr = AL.getArgAsExpr(2);
3387 Expr *IdxExpr = AL.getArgAsExpr(I);
3574 void Sema::AddAlignValueAttr(Decl *D, const AttributeCommonInfo &CI, Expr *E) {
3628 Expr *E = AL.getArgAsExpr(0);
3641 void Sema::AddAlignedAttr(Decl *D, const AttributeCommonInfo &CI, Expr *E,
4671 Expr *NumParamsExpr = AL.getArgAsExpr(0);
4699 static Expr *makeLaunchBoundsArgExpr(Sema &S, Expr *E,
4699 static Expr *makeLaunchBoundsArgExpr(Sema &S, Expr *E,
4733 return ValArg.getAs<Expr>();
4737 Expr *MaxThreads, Expr *MinBlocks) {
4737 Expr *MaxThreads, Expr *MinBlocks) {
5487 Expr *NumParamsExpr = static_cast<Expr *>(AL.getArgAsExpr(0));
5782 checkAMDGPUFlatWorkGroupSizeArguments(Sema &S, Expr *MinExpr, Expr *MaxExpr,
5782 checkAMDGPUFlatWorkGroupSizeArguments(Sema &S, Expr *MinExpr, Expr *MaxExpr,
5813 Expr *MinExpr, Expr *MaxExpr) {
5813 Expr *MinExpr, Expr *MaxExpr) {
5825 Expr *MinExpr = AL.getArgAsExpr(0);
5826 Expr *MaxExpr = AL.getArgAsExpr(1);
5831 static bool checkAMDGPUWavesPerEUArguments(Sema &S, Expr *MinExpr,
5832 Expr *MaxExpr,
5866 Expr *MinExpr, Expr *MaxExpr) {
5866 Expr *MinExpr, Expr *MaxExpr) {
5881 Expr *MinExpr = AL.getArgAsExpr(0);
5882 Expr *MaxExpr = (AL.getNumArgs() > 1) ? AL.getArgAsExpr(1) : nullptr;
5889 Expr *NumSGPRExpr = AL.getArgAsExpr(0);
5898 Expr *NumVGPRExpr = AL.getArgAsExpr(0);
5930 Expr *VersionExpr = static_cast<Expr *>(AL.getArgAsExpr(0));
6066 SmallVector<Expr*, 1> Args;
6076 SmallVector<Expr*, 1> Args;
6086 SmallVector<Expr*, 2> Args;
6097 SmallVector<Expr *, 1> Args;
6110 SmallVector<Expr*, 1> Args;
tools/clang/lib/Sema/SemaDeclCXX.cpp 61 Expr *DefaultArg;
65 CheckDefaultArgumentVisitor(Expr *defarg, Sema *s)
68 bool VisitExpr(Expr *Node);
76 bool CheckDefaultArgumentVisitor::VisitExpr(Expr *Node) {
127 Expr *E = *i;
220 void Sema::ImplicitExceptionSpecification::CalledExpr(Expr *E) {
250 Sema::SetParamDefaultArgument(ParmVarDecl *Param, Expr *Arg,
272 Arg = Result.getAs<Expr>();
300 Expr *DefaultArg) {
876 llvm::function_ref<ExprResult(SourceLocation, Expr *, unsigned)> GetInit) {
1191 Expr *Get = UnresolvedLookupExpr::Create(
1196 Expr *Arg = E.get();
1201 Expr *Init = E.get();
2087 if (!isa<Expr>(S))
2299 !Expr::isPotentialConstantExpr(Dcl, Diags)) {
3149 Expr *BW, const VirtSpecifiers &VS,
3160 Expr *BitWidth = static_cast<Expr*>(BW);
3534 Expr *Base = ME;
3601 void HandleValue(Expr *E, bool AddressOf) {
3661 void CheckInitializer(Expr *E, const CXXConstructorDecl *FieldConstructor,
3704 Expr *ArgExpr = E->getArg(0);
3718 Expr *Callee = E->getCallee();
3740 Expr *Callee = E->getCallee();
3833 Expr *InitExpr = FieldInit->getInit();
3869 Expr *InitExpr) {
3975 Expr *InitList,
3992 ArrayRef<Expr *> Args,
3995 Expr *List = ParenListExpr::Create(Context, LParenLoc, Args, RParenLoc);
4053 Expr *Init,
4218 Sema::BuildMemberInitializer(ValueDecl *Member, Expr *Init,
4294 Sema::BuildDelegatingInitializer(TypeSourceInfo *TInfo, Expr *Init,
4346 DelegationInit.getAs<Expr>(),
4352 Expr *Init, CXXRecordDecl *ClassDecl,
4478 BaseInit.getAs<Expr>(),
4483 static Expr *CastForMoving(Sema &SemaRef, Expr *E, QualType T = QualType()) {
4483 static Expr *CastForMoving(Sema &SemaRef, Expr *E, QualType T = QualType()) {
4533 Expr *CopyCtorArg =
4576 BaseInit.getAs<Expr>(),
4583 static bool RefersToRValueRef(Expr *MemRef) {
4607 Expr *MemberExprBase =
4655 Expr *CtorArgE = CtorArg.getAs<Expr>();
4655 Expr *CtorArgE = CtorArg.getAs<Expr>();
4665 SemaRef.Context, Indirect, Loc, Loc, MemberInit.getAs<Expr>(), Loc);
4668 SemaRef.Context, Field, Loc, Loc, MemberInit.getAs<Expr>(), Loc);
8741 Expr *ThisArg = nullptr;
11234 Expr *E = FD->getInClassInitializer();
11302 ExplicitSpecifier Sema::ActOnExplicitBoolSpecifier(Expr *ExplicitExpr) {
11903 static Expr *assertNotNull(Expr *E) {
11903 static Expr *assertNotNull(Expr *E) {
11912 virtual Expr *build(Sema &S, SourceLocation Loc) const = 0;
11920 Expr *build(Sema &S, SourceLocation Loc) const override {
11930 Expr *build(Sema &S, SourceLocation Loc) const override {
11931 return assertNotNull(S.ActOnCXXThis(Loc).getAs<Expr>());
11942 Expr *build(Sema &S, SourceLocation Loc) const override {
11957 Expr *build(Sema &S, SourceLocation Loc) const override {
11973 Expr *build(Sema &S, SourceLocation Loc) const override {
11989 Expr *build(Sema &S, SourceLocation Loc) const override {
12000 Expr *build(Sema &S, SourceLocation Loc) const override {
12013 Expr *build(Sema &S, SourceLocation Loc) const override {
12039 Expr *From = FromB.build(S, Loc);
12043 Expr *To = ToB.build(S, Loc);
12071 Expr *CallArgs[] = {
12194 Expr *FromInst = From.build(S, Loc);
12196 OpEqualRef.getAs<Expr>(),
12280 Expr *Comparison
12289 Expr *Increment = new (S.Context)
12546 Statements.push_back(Copy.getAs<Expr>());
12914 Statements.push_back(Move.getAs<Expr>());
13327 Expr *FunctionRef = BuildDeclRefExpr(Invoker, Invoker->getType(),
13353 Expr *This = ActOnCXXThis(CurrentLocation).get();
13354 Expr *DerefThis =CreateBuiltinUnaryOp(CurrentLocation, UO_Deref, This).get();
13440 Expr *SubExpr = ExprArgs[0];
13638 SmallVectorImpl<Expr*> &ConvertedArgs,
13643 Expr **Args = ArgsPtr.data();
13658 SmallVector<Expr *, 8> AllArgs;
14193 Expr *LangStr,
14356 Expr *opaqueValue =
14367 Expr *init = MaybeCreateExprWithCleanups(construct);
14437 Expr *AssertExpr,
14438 Expr *AssertMessageExpr,
14451 Expr *AssertExpr,
14485 Expr *InnerCond = nullptr;
15295 if (!isa<Expr>(SubStmt))
15819 MemberInit.getAs<Expr>(),
16015 Expr *Arg = nullptr;
16016 ArrayRef<Expr *> Args;
16059 ArrayRef<SourceRange> DynamicExceptionRanges, Expr *NoexceptExpr,
16110 Expr *NoexceptExpr) {
16146 Expr *BitWidth,
tools/clang/lib/Sema/SemaExceptionSpec.cpp 79 Expr *NoexceptExpr,
898 bool Sema::CheckExceptionSpecCompatibility(Expr *From, QualType ToType) {
973 static CanThrowResult canSubExprsThrow(Sema &S, const Expr *E) {
976 R = mergeCanThrow(R, S.canThrow(cast<Expr>(SubStmt)));
983 static CanThrowResult canCalleeThrow(Sema &S, const Expr *E, const Decl *D) {
1053 Expr *Op = DC->getExprOperand();
1070 CanThrowResult Sema::canThrow(const Expr *E) {
1075 case Expr::ConstantExprClass:
1078 case Expr::CXXThrowExprClass:
1082 case Expr::CXXDynamicCastExprClass: {
1091 case Expr::CXXTypeidExprClass:
1099 case Expr::CallExprClass:
1100 case Expr::CXXMemberCallExprClass:
1101 case Expr::CXXOperatorCallExprClass:
1102 case Expr::UserDefinedLiteralClass: {
1116 case Expr::CXXConstructExprClass:
1117 case Expr::CXXTemporaryObjectExprClass: {
1125 case Expr::CXXInheritedCtorInitExprClass:
1129 case Expr::LambdaExprClass: {
1140 case Expr::CXXNewExprClass: {
1151 case Expr::CXXDeleteExprClass: {
1171 case Expr::CXXBindTemporaryExprClass: {
1182 case Expr::ObjCMessageExprClass:
1183 case Expr::ObjCPropertyRefExprClass:
1184 case Expr::ObjCSubscriptRefExprClass:
1190 case Expr::ObjCArrayLiteralClass:
1191 case Expr::ObjCDictionaryLiteralClass:
1192 case Expr::ObjCBoxedExprClass:
1197 case Expr::CoawaitExprClass:
1198 case Expr::ConditionalOperatorClass:
1199 case Expr::CompoundLiteralExprClass:
1200 case Expr::CoyieldExprClass:
1201 case Expr::CXXConstCastExprClass:
1202 case Expr::CXXReinterpretCastExprClass:
1203 case Expr::CXXRewrittenBinaryOperatorClass:
1204 case Expr::BuiltinBitCastExprClass:
1205 case Expr::CXXStdInitializerListExprClass:
1206 case Expr::DesignatedInitExprClass:
1207 case Expr::DesignatedInitUpdateExprClass:
1208 case Expr::ExprWithCleanupsClass:
1209 case Expr::ExtVectorElementExprClass:
1210 case Expr::InitListExprClass:
1211 case Expr::ArrayInitLoopExprClass:
1212 case Expr::MemberExprClass:
1213 case Expr::ObjCIsaExprClass:
1214 case Expr::ObjCIvarRefExprClass:
1215 case Expr::ParenExprClass:
1216 case Expr::ParenListExprClass:
1217 case Expr::ShuffleVectorExprClass:
1218 case Expr::ConvertVectorExprClass:
1219 case Expr::VAArgExprClass:
1223 case Expr::ArraySubscriptExprClass:
1224 case Expr::OMPArraySectionExprClass:
1225 case Expr::BinaryOperatorClass:
1226 case Expr::DependentCoawaitExprClass:
1227 case Expr::CompoundAssignOperatorClass:
1228 case Expr::CStyleCastExprClass:
1229 case Expr::CXXStaticCastExprClass:
1230 case Expr::CXXFunctionalCastExprClass:
1231 case Expr::ImplicitCastExprClass:
1232 case Expr::MaterializeTemporaryExprClass:
1233 case Expr::UnaryOperatorClass: {
1239 case Expr::StmtExprClass:
1242 case Expr::CXXDefaultArgExprClass:
1245 case Expr::CXXDefaultInitExprClass:
1248 case Expr::ChooseExprClass:
1253 case Expr::GenericSelectionExprClass:
1259 case Expr::CXXDependentScopeMemberExprClass:
1260 case Expr::CXXUnresolvedConstructExprClass:
1261 case Expr::DependentScopeDeclRefExprClass:
1262 case Expr::CXXFoldExprClass:
1265 case Expr::AsTypeExprClass:
1266 case Expr::BinaryConditionalOperatorClass:
1267 case Expr::BlockExprClass:
1268 case Expr::CUDAKernelCallExprClass:
1269 case Expr::DeclRefExprClass:
1270 case Expr::ObjCBridgedCastExprClass:
1271 case Expr::ObjCIndirectCopyRestoreExprClass:
1272 case Expr::ObjCProtocolExprClass:
1273 case Expr::ObjCSelectorExprClass:
1274 case Expr::ObjCAvailabilityCheckExprClass:
1275 case Expr::OffsetOfExprClass:
1276 case Expr::PackExpansionExprClass:
1277 case Expr::PseudoObjectExprClass:
1278 case Expr::SubstNonTypeTemplateParmExprClass:
1279 case Expr::SubstNonTypeTemplateParmPackExprClass:
1280 case Expr::FunctionParmPackExprClass:
1281 case Expr::UnaryExprOrTypeTraitExprClass:
1282 case Expr::UnresolvedLookupExprClass:
1283 case Expr::UnresolvedMemberExprClass:
1284 case Expr::TypoExprClass:
1288 case Expr::AddrLabelExprClass:
1289 case Expr::ArrayTypeTraitExprClass:
1290 case Expr::AtomicExprClass:
1291 case Expr::TypeTraitExprClass:
1292 case Expr::CXXBoolLiteralExprClass:
1293 case Expr::CXXNoexceptExprClass:
1294 case Expr::CXXNullPtrLiteralExprClass:
1295 case Expr::CXXPseudoDestructorExprClass:
1296 case Expr::CXXScalarValueInitExprClass:
1297 case Expr::CXXThisExprClass:
1298 case Expr::CXXUuidofExprClass:
1299 case Expr::CharacterLiteralClass:
1300 case Expr::ExpressionTraitExprClass:
1301 case Expr::FloatingLiteralClass:
1302 case Expr::GNUNullExprClass:
1303 case Expr::ImaginaryLiteralClass:
1304 case Expr::ImplicitValueInitExprClass:
1305 case Expr::IntegerLiteralClass:
1306 case Expr::FixedPointLiteralClass:
1307 case Expr::ArrayInitIndexExprClass:
1308 case Expr::NoInitExprClass:
1309 case Expr::ObjCEncodeExprClass:
1310 case Expr::ObjCStringLiteralClass:
1311 case Expr::ObjCBoolLiteralExprClass:
1312 case Expr::OpaqueValueExprClass:
1313 case Expr::PredefinedExprClass:
1314 case Expr::SizeOfPackExprClass:
1315 case Expr::StringLiteralClass:
1316 case Expr::SourceLocExprClass:
1317 case Expr::ConceptSpecializationExprClass:
1321 case Expr::MSPropertyRefExprClass:
1322 case Expr::MSPropertySubscriptExprClass:
1331 case Expr::NoStmtClass:
tools/clang/lib/Sema/SemaExpr.cpp 341 ArrayRef<Expr *> Args) {
402 Expr *sentinelExpr = Args[Args.size() - numArgsAfterSentinel - 1];
431 SourceRange Sema::getExprRange(Expr *E) const {
478 static void CheckForNullPointerDereference(Sema &S, Expr *E) {
487 isNullPointerConstant(S.Context, Expr::NPC_ValueDependentIsNotNull) &&
499 const Expr* RHS) {
509 const Expr *Base = OIRE->getBase();
840 void Sema::checkVariadicArgument(const Expr *E, VariadicCallType CT) {
1735 Expr *Args[] = { Lit, LenArg };
1846 if (auto *BE = BD->getBinding())
1886 DeclarationName Typo, SourceLocation TypoLoc, ArrayRef<Expr *> Args,
1923 ArrayRef<Expr *> Args, TypoExpr **Out) {
2118 static Expr *
2254 if (Expr *Ex = E.getAs<Expr>())
2254 if (Expr *Ex = E.getAs<Expr>())
2275 if (Expr *E = recoverFromMSUnqualifiedLookup(*this, Context, NameInfo,
3304 Expr *Lit = new (Context) CharacterLiteral(Literal.getValue(), Kind, Ty,
3331 static Expr *BuildFloatingLiteral(Sema &S, NumericLiteralParser &Literal,
3363 bool Sema::CheckLoopHintExpr(Expr *E, SourceLocation Loc) {
3460 Expr *Lit;
3482 Expr *Lit = StringLiteral::Create(
3511 Expr *Res;
3800 Expr *E) {
3822 bool Sema::CheckUnaryExprOrTypeTraitOperand(Expr *E,
3973 static bool CheckAlignOfExpr(Sema &S, Expr *E, UnaryExprOrTypeTrait ExprKind) {
3985 Expr *Inner = E->IgnoreParens();
4029 bool Sema::CheckVecStepExpr(Expr *E) {
4246 Expr *ArgEx = (Expr *)TyOrEx;
4310 Expr *op) {
4322 static bool isMSPropertySubscriptExpr(Sema &S, Expr *Base) {
4323 auto *BaseNoParens = Base->IgnoreParens();
4419 void Sema::CheckAddressOfNoDeref(const Expr *E) {
4421 const Expr *StrippedExpr = E->IgnoreParenImpCasts();
4447 const Expr *Base = E->getBase();
4562 Expr::EvalResult Result;
4576 Expr::EvalResult Result;
4614 Expr *LHSExp = Base;
4615 Expr *RHSExp = Idx;
4623 for (auto *Op : {LHSExp, RHSExp}) {
4648 Expr *BaseExpr, *IndexExpr;
4816 Expr *UninstExpr = Param->getUninstantiatedDefaultArg();
4873 Expr *ResultE = Result.getAs<Expr>();
4873 Expr *ResultE = Result.getAs<Expr>();
4881 ActOnFinishFullExpr(Result.getAs<Expr>(), Param->getOuterLocStart(),
4887 Param->setDefaultArg(Result.getAs<Expr>());
4938 Expr *Fn) {
4981 static TypoCorrection TryTypoCorrectionForCall(Sema &S, Expr *Fn,
4983 ArrayRef<Expr *> Args) {
5026 Sema::ConvertArgumentsForCall(CallExpr *Call, Expr *Fn,
5029 ArrayRef<Expr *> Args,
5128 SmallVector<Expr *, 8> AllArgs;
5144 unsigned FirstParam, ArrayRef<Expr *> Args,
5145 SmallVectorImpl<Expr *> &AllArgs,
5155 Expr *Arg;
5194 Arg = ArgE.getAs<Expr>();
5202 Arg = ArgExpr.getAs<Expr>();
5222 for (Expr *A : Args.slice(ArgIx)) {
5231 for (Expr *A : Args.slice(ArgIx)) {
5239 for (Expr *A : Args.slice(ArgIx))
5265 const Expr *ArgExpr) {
5277 Expr::NPC_NeverValueDependent)) {
5424 Expr *Arg = ArgRes.get();
5476 static void checkDirectCallValidity(Sema &S, const Expr *Fn,
5642 if (Fn->isTypeDependent() || Expr::hasAnyTypeDependentArguments(ArgExprs)) {
5681 if (Expr::hasAnyTypeDependentArguments(ArgExprs))
5701 Expr *NakedFn = Fn->IgnoreParens();
5947 TheCall->setValueKind(Expr::getValueKindForType(FuncT->getReturnType()));
5975 Expr *Arg = Args[i];
5985 Arg = ArgE.getAs<Expr>();
5993 Arg = ArgE.getAs<Expr>();
6108 Expr *Init = ILE->getInit(i);
6350 Expr::NPC_ValueDependentIsNull))
6688 Expr *E = (PE ? PE->getSubExpr() : PLE->getExpr(0));
6729 Expr **exprs;
6731 Expr *subExpr;
6749 SmallVector<Expr *, 8> initExprs;
6831 bool Sema::DiagnoseConditionalForNull(Expr *LHSExpr, Expr *RHSExpr,
6831 bool Sema::DiagnoseConditionalForNull(Expr *LHSExpr, Expr *RHSExpr,
6833 Expr *NullExpr = LHSExpr;
6834 Expr *NonPointerExpr = RHSExpr;
6835 Expr::NullPointerConstantKind NullKind =
6837 Expr::NPC_ValueDependentIsNotNull);
6839 if (NullKind == Expr::NPCK_NotNull) {
6844 Expr::NPC_ValueDependentIsNotNull);
6847 if (NullKind == Expr::NPCK_NotNull)
6850 if (NullKind == Expr::NPCK_ZeroExpression)
6853 if (NullKind == Expr::NPCK_ZeroLiteral) {
6862 int DiagType = (NullKind == Expr::NPCK_CXX11_nullptr);
6870 static bool checkCondition(Sema &S, Expr *Cond, SourceLocation QuestionLoc) {
6891 Expr *LHSExpr = LHS.get();
6892 Expr *RHSExpr = RHS.get();
6911 Expr::NPC_ValueDependentIsNull))
7121 Expr *Expr1 = IsIntFirstExpr ? Int.get() : PointerExpr;
7122 Expr *Expr2 = IsIntFirstExpr ? PointerExpr : Int.get();
7233 static bool checkOpenCLConditionVector(Sema &S, Expr *Cond,
7313 static bool checkBlockType(Sema &S, const Expr *E) {
7635 static bool IsArithmeticBinaryExpr(Expr *E, BinaryOperatorKind *Opcode,
7636 Expr **RHSExprs) {
7681 static bool ExprLooksBoolean(Expr *E) {
7704 Expr *Condition,
7705 Expr *LHSExpr,
7706 Expr *RHSExpr) {
7708 Expr *CondRHS;
7819 Expr *commonExpr = nullptr;
8476 Expr *E = EResult.get();
8517 Expr::NPC_ValueDependentIsNull)) {
8618 Expr::NPC_ValueDependentIsNull)) {
8632 Context, Expr::NPC_ValueDependentIsNull)) {
8661 Expr *E = RHS.get();
8696 explicit OriginalOperand(Expr *Op) : Orig(Op), Conversion(nullptr) {
8709 Expr *Orig;
8750 Expr *Vector = LHSNatVec ? LHS.get() : RHS.get();
8751 Expr *NonVector = !LHSNatVec ? LHS.get() : RHS.get();
8850 Expr::EvalResult EVResult;
8887 Expr::EvalResult EVResult;
9207 static void DiagnoseDivisionSizeofPointerOrArray(Sema &S, Expr *LHS, Expr *RHS,
9207 static void DiagnoseDivisionSizeofPointerOrArray(Sema &S, Expr *LHS, Expr *RHS,
9217 const Expr *LHSArg = LUE->getArgumentExpr()->IgnoreParens();
9259 Expr::EvalResult RHSValue;
9319 Expr *LHSExpr, Expr *RHSExpr) {
9319 Expr *LHSExpr, Expr *RHSExpr) {
9329 Expr *Pointer) {
9342 Expr *Pointer, bool IsGNUIdiom) {
9353 Expr *LHS, Expr *RHS) {
9353 Expr *LHS, Expr *RHS) {
9369 Expr *Pointer) {
9383 Expr *Operand) {
9404 Expr *Operand) {
9436 Expr *LHSExpr, Expr *RHSExpr) {
9436 Expr *LHSExpr, Expr *RHSExpr) {
9491 Expr *LHSExpr, Expr *RHSExpr) {
9491 Expr *LHSExpr, Expr *RHSExpr) {
9493 Expr* IndexExpr = RHSExpr;
9521 Expr *LHSExpr, Expr *RHSExpr) {
9521 Expr *LHSExpr, Expr *RHSExpr) {
9522 const Expr *StringRefExpr = LHSExpr;
9572 Expr *LHSExpr, Expr *RHSExpr) {
9572 Expr *LHSExpr, Expr *RHSExpr) {
9614 Expr *PExp = LHS.get(), *IExp = RHS.get();
9638 Context, Expr::NPC_ValueDependentIsNotNull)) {
9640 Expr::EvalResult KnownVal;
9717 Expr::NPC_ValueDependentIsNotNull)) {
9719 Expr::EvalResult KnownVal;
9800 Expr::EvalResult RHSResult;
9829 Expr::EvalResult LHSResult;
10022 static void checkEnumComparison(Sema &S, SourceLocation Loc, Expr *LHS,
10023 Expr *RHS) {
10116 static bool hasIsEqualMethod(Sema &S, const Expr *LHS, const Expr *RHS) {
10116 static bool hasIsEqualMethod(Sema &S, const Expr *LHS, const Expr *RHS) {
10162 Sema::ObjCLiteralKind Sema::CheckLiteralKind(Expr *FromE) {
10179 Expr *Inner = cast<ObjCBoxedExpr>(FromE)->getSubExpr()->IgnoreParens();
10207 Expr *Literal;
10208 Expr *Other;
10220 Expr::NPC_ValueDependentIsNotNull))
10265 Expr *SubExpr = UO->getSubExpr()->IgnoreImpCasts();
10296 static bool checkForArray(const Expr *E) {
10311 Expr *LHS, Expr *RHS,
10311 Expr *LHS, Expr *RHS,
10313 Expr *LHSStripped = LHS->IgnoreParenImpCasts();
10314 Expr *RHSStripped = RHS->IgnoreParenImpCasts();
10348 if (Expr::isSameComparisonOperand(LHS, RHS)) {
10396 Expr *LiteralString = nullptr;
10397 Expr *LiteralStringStripped = nullptr;
10400 Expr::NPC_ValueDependentIsNull)) {
10406 Expr::NPC_ValueDependentIsNull)) {
10456 static bool checkThreeWayNarrowingConversion(Sema &S, QualType ToType, Expr *E,
10623 Expr::NPC_ValueDependentIsNotNull) ==
10624 Expr::NPCK_ZeroExpression) {
10695 const Expr::NullPointerConstantKind LHSNullKind =
10696 LHS.get()->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull);
10697 const Expr::NullPointerConstantKind RHSNullKind =
10698 RHS.get()->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull);
10699 bool LHSIsNull = LHSNullKind != Expr::NPCK_NotNull;
10700 bool RHSIsNull = RHSNullKind != Expr::NPCK_NotNull;
10963 Expr *E = LHS.get();
10971 Expr *E = RHS.get();
11369 Expr::EvalResult EVResult;
11441 static bool IsReadonlyMessage(Expr *E, Sema &S) {
11455 static NonConstCaptureKind isReferenceToNonConstCapture(Sema &S, Expr *E) {
11513 static void DiagnoseConstAssignment(Sema &S, const Expr *E,
11679 static void DiagnoseRecursiveConstFields(Sema &S, const Expr *E,
11702 static bool CheckForModifiableLvalue(Expr *E, SourceLocation Loc, Sema &S) {
11708 Expr::isModifiableLvalueResult IsLV = E->isModifiableLvalue(S.Context,
11710 if (IsLV == Expr::MLV_ClassTemporary && IsReadonlyMessage(E, S))
11711 IsLV = Expr::MLV_InvalidMessageExpression;
11712 if (IsLV == Expr::MLV_Valid)
11718 case Expr::MLV_ConstQualified:
11778 case Expr::MLV_ConstAddrSpace:
11781 case Expr::MLV_ConstQualifiedField:
11784 case Expr::MLV_ArrayType:
11785 case Expr::MLV_ArrayTemporary:
11789 case Expr::MLV_NotObjectType:
11793 case Expr::MLV_LValueCast:
11796 case Expr::MLV_Valid:
11798 case Expr::MLV_InvalidExpression:
11799 case Expr::MLV_MemberFunction:
11800 case Expr::MLV_ClassTemporary:
11803 case Expr::MLV_IncompleteType:
11804 case Expr::MLV_IncompleteVoidType:
11807 case Expr::MLV_DuplicateVectorComponents:
11810 case Expr::MLV_NoSetterProperty:
11812 case Expr::MLV_InvalidMessageExpression:
11815 case Expr::MLV_SubObjCPropertySetting:
11830 static void CheckIdentityFieldAssignment(Expr *LHSExpr, Expr *RHSExpr,
11830 static void CheckIdentityFieldAssignment(Expr *LHSExpr, Expr *RHSExpr,
11875 QualType Sema::CheckAssignmentOperands(Expr *LHSExpr, ExprResult &RHS,
11899 Expr *RHSCheck = RHS.get();
11945 const Expr *InnerLHS = LHSExpr->IgnoreParenCasts();
12008 static bool IgnoreCommaOperand(const Expr *E) {
12029 void Sema::DiagnoseCommaOperator(const Expr *LHS, SourceLocation Loc) {
12114 static QualType CheckIncrementDecrementOperand(Sema &S, Expr *Op,
12216 static ValueDecl *getPrimaryDecl(Expr *E) {
12231 Expr* Base = cast<ArraySubscriptExpr>(E)->getBase();
12274 Expr *E, unsigned Type) {
12288 Expr *E = OrigOp.get()->IgnoreParens();
12326 Expr *op = OrigOp.get()->IgnoreParens();
12359 Expr::LValueClassification lval = op->ClassifyLValue(Context);
12362 if (lval == Expr::LV_ClassTemporary || lval == Expr::LV_ArrayTemporary) {
12362 if (lval == Expr::LV_ClassTemporary || lval == Expr::LV_ArrayTemporary) {
12374 } else if (lval == Expr::LV_MemberFunction) {
12416 } else if (lval != Expr::LV_Valid && lval != Expr::LV_IncompleteVoidType) {
12416 } else if (lval != Expr::LV_Valid && lval != Expr::LV_IncompleteVoidType) {
12485 if (lval == Expr::LV_IncompleteVoidType) {
12501 static void RecordModifiableNonNullParam(Sema &S, const Expr *Exp) {
12520 static QualType CheckIndirectionOperand(Sema &S, Expr *Op, ExprValueKind &VK,
12644 static void DiagnoseSelfAssignment(Sema &S, Expr *LHSExpr, Expr *RHSExpr,
12644 static void DiagnoseSelfAssignment(Sema &S, Expr *LHSExpr, Expr *RHSExpr,
12685 const Expr *ObjCPointerExpr = nullptr, *OtherExpr = nullptr;
12686 const Expr *LHS = L.get();
12687 const Expr *RHS = R.get();
12705 const Expr *Ex = ObjCPointerExpr->IgnoreParenCasts();
12721 static NamedDecl *getDeclFromExpr(Expr *E) {
13078 SourceLocation OpLoc, Expr *LHSExpr,
13079 Expr *RHSExpr) {
13133 static bool EvaluatesAsTrue(Sema &S, Expr *E) {
13141 static bool EvaluatesAsFalse(Sema &S, Expr *E) {
13149 Expr *LHSExpr, Expr *RHSExpr) {
13149 Expr *LHSExpr, Expr *RHSExpr) {
13171 Expr *LHSExpr, Expr *RHSExpr) {
13171 Expr *LHSExpr, Expr *RHSExpr) {
13188 SourceLocation OpLoc, Expr *SubExpr) {
13203 Expr *SubExpr, StringRef Shift) {
13217 Expr *LHSExpr, Expr *RHSExpr) {
13217 Expr *LHSExpr, Expr *RHSExpr) {
13245 SourceLocation OpLoc, Expr *LHSExpr,
13246 Expr *RHSExpr){
13674 bool Sema::isQualifiedMemberAccess(Expr *E) {
13809 if (const Expr *Value = LastStmt->getExprStmt()) {
13818 Expr *ResStmtExpr = new (Context) StmtExpr(Compound, Ty, LPLoc, RPLoc);
13833 Expr *E = ER.get();
13880 SmallVector<Expr*, 4> Exprs;
13896 Expr *Idx = IdxRval.get();
14063 Expr *ActiveExpr = CondIsTrue ? LHSExpr : RHSExpr;
14338 Expr *CopyExpr = nullptr;
14434 Expr *OrigExpr = E;
14485 E = Init.getAs<Expr>();
14577 bool Sema::ConversionToObjCStringLiteralCheck(QualType DstType, Expr *&Exp,
14596 Expr *SrcExpr = Exp->IgnoreParenImpCasts();
14613 const Expr *SrcExpr) {
14634 Expr *SrcExpr, AssignmentAction Action,
14961 Expr::EvalResult EvalResult;
15090 const DeclRefExpr *CheckPossibleDeref(Sema &S, const Expr *PossibleDeref) {
15118 for (const Expr *E : Rec.PossibleDerefs) {
15137 void Sema::CheckUnusedVolatileAssignment(Expr *E) {
15190 for (auto *BO : Rec.VolatileAssignmentLHSs)
16385 case Expr::DeclRefExprClass: {
16399 case Expr::FunctionParmPackExprClass: {
16415 case Expr::ArraySubscriptExprClass: {
16417 Expr *OldBase = ASE->getBase()->IgnoreImplicit();
16423 Expr *LHS = ASE->getBase() == ASE->getLHS() ? Base.get() : ASE->getLHS();
16424 Expr *RHS = ASE->getBase() == ASE->getRHS() ? Base.get() : ASE->getRHS();
16430 case Expr::MemberExprClass: {
16464 case Expr::BinaryOperatorClass: {
16466 Expr *LHS = BO->getLHS();
16467 Expr *RHS = BO->getRHS();
16488 case Expr::ParenExprClass: {
16498 case Expr::ConditionalOperatorClass: {
16518 case Expr::UnaryOperatorClass: {
16532 case Expr::GenericSelectionExprClass: {
16535 SmallVector<Expr *, 4> AssocExprs;
16537 for (Expr *OrigAssocExpr : GSE->getAssocExprs()) {
16560 case Expr::ChooseExprClass: {
16583 case Expr::ConstantExprClass: {
16593 case Expr::ImplicitCastExprClass: {
16666 for (Expr *E : LocalMaybeODRUseExprs) {
16686 VarDecl *Var, Expr *E) {
16865 Decl *D, Expr *E, bool MightBeOdrUse) {
16899 void Sema::MarkDeclRefReferenced(DeclRefExpr *E, const Expr *Base) {
17070 void Sema::MarkDeclarationsReferencedInExpr(Expr *E,
17183 void Sema::DiagnoseAssignmentAsCondition(Expr *E) {
17250 Expr *E = ParenE->IgnoreParens();
17255 == Expr::MLV_Valid) {
17300 Expr *SubExpr, ConditionKind CK) {
17357 Expr *SubExpr = SubResult.get();
17377 Expr *SubExpr = SubResult.get();
17451 Expr *SubExpr = SubResult.get();
17509 Expr *CalleeExpr = E->getCallee();
17522 CalleeType = Expr::findBoundMemberType(CalleeExpr);
17545 E->setValueKind(Expr::getValueKindForType(DestType));
17575 Expr *Arg = E->getArg(i);
17633 E->setValueKind(Expr::getValueKindForType(DestType));
17813 Expr *orig = E;
17895 const Expr *BME = E->IgnoreParens();
17912 Expr *realCast = stripARCUnbridgedCast(E);
17967 bool Sema::CheckCaseExpression(Expr *E) {
tools/clang/lib/Sema/SemaExprCXX.cpp 653 if (E->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull)) {
863 QualType ExceptionObjectTy, Expr *E) {
1268 Expr *Sema::BuildCXXThisExpr(SourceLocation Loc, QualType Type,
1373 Expr *Arg = Exprs[0];
1409 Expr *Inner = Result.get();
1427 Context, ResultType, Expr::getValueKindForType(Ty), TInfo, CK_NoOp,
1653 Optional<Expr *> ArraySize;
1679 if (Expr *NumElts = (Expr *)Array.NumElts) {
1721 Expr *Init) {
1796 Expr **Inits = &Initializer;
1854 Expr *FirstBad = Inits[1];
1862 Expr *Deduce = Inits[0];
1928 Expr *ArraySize;
1931 SizeConvertDiagnoser(Expr *ArraySize)
2048 !Expr::hasAnyTypeDependentArguments(PlacementArgs) &&
2062 SmallVector<Expr *, 8> AllPlaceArgs;
2113 !Expr::hasAnyTypeDependentArguments(
2223 Sema &S, LookupResult &R, SourceRange Range, SmallVectorImpl<Expr *> &Args,
2225 OverloadCandidateSet *AlignedCandidates, Expr *AlignArg, bool Diagnose) {
2362 SmallVector<Expr*, 8> AllocArgs;
3013 const CXXNewExpr *getNewExprFromInitListOrExpr(const Expr *E);
3053 const Expr *E = DE->getArgument()->IgnoreParenImpCasts();
3064 MismatchingNewDeleteDetector::getNewExprFromInitListOrExpr(const Expr *E) {
3107 const Expr *InitExpr = Field->getInClassInitializer();
3458 SmallVector<Expr *, 8> Args(TheCall->arg_begin(), TheCall->arg_end());
3690 Sema::IsStringLiteralToNonConstPointerConversion(Expr *From, QualType ToType) {
3737 SmallVector<Expr*, 8> ConstructorArgs;
3759 return S.MaybeBindToTemporary(Result.getAs<Expr>());
3907 SmallVector<Expr*, 8> ConstructorArgs;
4169 Expr *Elem = prepareVectorSplat(ToType, From).get();
4963 SmallVector<Expr *, 2> ArgExprs;
4972 Expr::getValueKindForType(ArgTy)));
4974 for (Expr &E : OpaqueArgExprs)
5181 Expr::getValueKindForType(LhsT));
5182 Expr *FromPtr = &From;
5234 Expr::getValueKindForType(LhsT));
5236 Expr::getValueKindForType(RhsT));
5292 QualType T, Expr *DimExpr,
5380 static bool EvaluateExpressionTrait(ExpressionTrait ET, Expr *E) {
5568 static bool TryClassUnification(Sema &Self, Expr *From, Expr *To,
5568 static bool TryClassUnification(Sema &Self, Expr *From, Expr *To,
5662 Expr *Args[2] = { LHS.get(), RHS.get() };
5723 Expr *Arg = E.get();
5784 Expr *NonThrow = LThrow ? RHS.get() : LHS.get();
6111 Expr *&E1, Expr *&E2,
6111 Expr *&E1, Expr *&E2,
6135 E2->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull)) {
6143 E1->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull)) {
6304 Expr *&E1, *&E2;
6311 Conversion(Sema &S, SourceLocation Loc, Expr *&E1, Expr *&E2,
6311 Conversion(Sema &S, SourceLocation Loc, Expr *&E1, Expr *&E2,
6323 E1 = E1Result.getAs<Expr>();
6328 E2 = E2Result.getAs<Expr>();
6377 Expr *Callee = Call->getCallee()->IgnoreParens();
6526 Expr *Sema::MaybeCreateExprWithCleanups(Expr *SubExpr) {
6526 Expr *Sema::MaybeCreateExprWithCleanups(Expr *SubExpr) {
6562 Expr *E = new (Context) StmtExpr(CompStmt, Context.VoidTy, SourceLocation(),
6845 static bool CheckArrow(Sema& S, QualType& ObjectType, Expr *&Base,
7003 Expr *Result
7197 Expr *SubE = E;
7231 ExprValueKind VK = Expr::getValueKindForType(ResultType);
7275 static bool IsSpecialDiscardedValue(Expr *E) {
7436 Expr *Init = cast<Expr>(Eval->Value);
7436 Expr *Init = cast<Expr>(Eval->Value);
7456 Expr *const FE, LambdaScopeInfo *const CurrentLSI, Sema &S) {
7619 llvm::SmallDenseMap<OverloadExpr *, Expr *, 4> OverloadResolution;
7674 NamedDecl *getDeclFromExpr(Expr *E) {
7708 Expr *FixedExpr = Res.get();
7855 Expr *ResultCall = Result.get();
tools/clang/lib/Sema/SemaExprMember.cpp 480 Sema::ActOnDependentMemberExpr(Expr *BaseExpr, QualType BaseType,
523 Expr *BaseExpr,
549 bool Sema::CheckQualifiedMemberReference(Expr *BaseExpr,
642 Expr *BaseExpr,
744 Sema::BuildMemberReferenceExpr(Expr *Base, QualType BaseType,
807 Expr *baseObjectExpr,
839 Expr *result = baseObjectExpr;
884 BuildMSPropertyRefExpr(Sema &S, Expr *BaseExpr, bool IsArrow,
897 Expr *Base, bool IsArrow, SourceLocation OpLoc, const CXXScopeSpec *SS,
910 Expr *Base, bool IsArrow, SourceLocation OpLoc, NestedNameSpecifierLoc NNS,
960 Sema::BuildMemberReferenceExpr(Expr *BaseExpr, QualType BaseExprType,
1228 Sema::PerformMemberExprBaseConversion(Expr *Base, bool IsArrow) {
1437 Expr *BaseExp = BaseExpr.get()->IgnoreParenImpCasts();
1685 ExprResult Sema::ActOnMemberAccessExpr(Scope *S, Expr *Base,
1756 Sema::BuildFieldReferenceExpr(Expr *BaseExpr, bool IsArrow,
1849 Expr *baseExpr = nullptr; // null signifies implicit access
tools/clang/lib/Sema/SemaExprObjC.cpp 35 ArrayRef<Expr *> Strings) {
48 for (Expr *E : Strings) {
314 ExprResult Sema::BuildObjCNumericLiteral(SourceLocation AtLoc, Expr *Number) {
384 static ExprResult CheckObjCCollectionLiteralElement(Sema &S, Expr *Element,
409 Expr *OrigElement = Element;
498 ExprResult Sema::BuildObjCBoxedExpr(SourceRange SR, Expr *ValueExpr) {
765 ExprResult Sema::BuildObjCSubscriptExpression(SourceLocation RB, Expr *BaseExpr,
766 Expr *IndexExpr,
879 Expr **ElementsBuffer = Elements.data();
1368 QualType Sema::getMessageSendResultType(const Expr *Receiver,
1527 void Sema::EmitRelatedResultTypeNote(const Expr *E) {
1554 const Expr *Receiver, QualType ReceiverType, MultiExprArg Args,
1637 VK = Expr::getValueKindForType(Method->getReturnType());
1661 Expr *argExpr = Args[i];
1712 Args[i] = ArgE.getAs<Expr>();
1759 bool Sema::isSelfExpr(Expr *RExpr) {
1766 bool Sema::isSelfExpr(Expr *receiver, const ObjCMethodDecl *method) {
1818 Expr *BaseExpr, SourceLocation OpLoc,
2335 ArrayRef<Expr *> Args, QualType ReceiverType,
2386 Expr **Args, unsigned NumArgs) {
2405 Expr *FormatExpr = Args[Idx];
2475 Expr **Args = ArgsIn.data();
2529 Expr **Args = ArgsIn.data();
2612 ExprResult Sema::BuildInstanceMessageImplicit(Expr *Receiver,
2670 ExprResult Sema::BuildInstanceMessage(Expr *Receiver,
2718 Expr **Args = ArgsIn.data();
2754 Expr::NPC_ValueDependentIsNull);
3022 Expr **Args = ArgsIn.data();
3197 static void RemoveSelectorFromWarningCache(Sema &S, Expr* Arg) {
3212 Expr *Receiver,
3353 ACCResult Visit(Expr *e) {
3362 ACCResult VisitExpr(Expr *e) {
3363 if (e->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNotNull))
3550 Expr *castExpr,
3551 Expr *realCast,
3582 Expr *castedE = castExpr;
3628 Expr *castedE = castExpr->IgnoreImpCasts();
3672 Expr *castExpr, Expr *realCast,
3672 Expr *castExpr, Expr *realCast,
3802 static bool CheckObjCBridgeNSCast(Sema &S, QualType castType, Expr *castExpr,
3868 static bool CheckObjCBridgeCFCast(Sema &S, QualType castType, Expr *castExpr,
3936 void Sema::CheckTollFreeBridgeCast(QualType castType, Expr *castExpr) {
3986 void Sema::CheckObjCBridgeRelatedCast(QualType castType, Expr *castExpr) {
4007 bool Sema::CheckTollFreeBridgeStaticCast(QualType castType, Expr *castExpr,
4100 Expr *&SrcExpr, bool Diagnose) {
4138 Expr *args[] = { SrcExpr };
4194 Expr *&castExpr, CheckedConversionKind CCK,
4308 void Sema::diagnoseARCUnbridgedCast(Expr *e) {
4332 Expr *castExpr = realCast->getSubExpr();
4341 Expr *Sema::stripARCUnbridgedCast(Expr *e) {
4341 Expr *Sema::stripARCUnbridgedCast(Expr *e) {
4345 Expr *sub = stripARCUnbridgedCast(pe->getSubExpr());
4349 Expr *sub = stripARCUnbridgedCast(uo->getSubExpr());
4357 SmallVector<Expr *, 4> subExprs;
4363 Expr *sub = assoc.getAssociationExpr();
4397 static Expr *maybeUndoReclaimObject(Expr *e) {
4397 static Expr *maybeUndoReclaimObject(Expr *e) {
4398 Expr *curExpr = e, *prevExpr = nullptr;
4437 Expr *SubExpr) {
4531 Expr *Result = new (Context) ObjCBridgedCastExpr(LParenLoc, Kind, CK,
4550 Expr *SubExpr) {
tools/clang/lib/Sema/SemaFixItUtils.cpp 50 bool ConversionFixItGenerator::tryToFixConversion(const Expr *FullExpr,
65 const Expr* Expr = FullExpr->IgnoreImpCasts();
102 isNullPointerConstant(S.Context, Expr::NPC_ValueDependentIsNotNull))
tools/clang/lib/Sema/SemaInit.cpp 62 static StringInitFailureKind IsStringInit(Expr *Init, const ArrayType *AT,
135 static StringInitFailureKind IsStringInit(Expr *init, QualType declType,
145 static void updateStringLiteralType(Expr *E, QualType Ty) {
168 static void updateGNUCompoundLiteralRValue(Expr *E) {
188 static void CheckStringInit(Expr *Str, QualType &DeclT, const ArrayType *AT,
366 Expr *expr);
377 void diagnoseInitOverride(Expr *OldInit, SourceRange NewInitRange,
465 Expr *InitExpr, FieldDecl *Field,
488 Expr *InitExpr;
622 ILE->setInit(Init, BaseInit.getAs<Expr>());
654 Expr *Filler = new (SemaRef.Context) NoInitExpr(Field->getType());
709 ILE->setInit(Init, MemberInit.getAs<Expr>());
715 ILE->updateInit(SemaRef.Context, Init, MemberInit.getAs<Expr>());
864 Expr *InitExpr = (Init < NumInits ? ILE->getInit(Init) : nullptr);
873 Expr *Filler = nullptr;
885 Filler = ElementInit.getAs<Expr>();
1315 Expr *expr = IList->getInit(Index);
1373 Result.getAs<Expr>());
1430 ExprRes.getAs<Expr>());
1522 Expr *expr = IList->getInit(Index);
1556 Expr *ResultExpr = nullptr;
1561 ResultExpr = Result.getAs<Expr>();
1596 Expr *expr = IList->getInit(Index);
1622 expr = Result.getAs<Expr>();
1655 Expr *Init = IList->getInit(Index);
1669 Expr *ResultExpr = nullptr;
1673 ResultExpr = Result.getAs<Expr>();
1878 Expr *Init = IList->getInit(Index);
1955 Expr *InitExpr,
2056 Expr *Init = Index < IList->getNumInits() ? IList->getInit(Index) : nullptr;
2092 Expr *Init = IList->getInit(Index);
2286 SmallVector<Expr*, 4> IndexExprs(NumIndexExprs);
2375 Expr *Init = DIE->getInit();
2422 Expr *ExistingInit = StructuredIndex < StructuredList->getNumInits() ?
2581 Expr *ExistingInit = StructuredList->getInit(0);
2646 if (Expr *PrevInit = StructuredList->getInit(OldIndex)) {
2796 Expr *IndexExpr = nullptr;
2859 Expr *SubExpr = StructuredList->getInit(0)->IgnoreParens();
2881 Expr *Init = new (Context) IntegerLiteral(
2903 Expr *Init = new (Context) IntegerLiteral(
2980 Expr *ExistingInit = nullptr;
3077 Expr *expr) {
3082 if (Expr *PrevInit = StructuredList->updateInit(SemaRef.Context,
3110 CheckArrayDesignatorExpr(Sema &S, Expr *Index, llvm::APSInt &Value) {
3134 SmallVector<Expr *, 32> InitExpressions;
3146 Expr *Index = static_cast<Expr *>(D.getArrayIndex());
3162 Expr *StartIndex = static_cast<Expr *>(D.getArrayRangeStart());
3163 Expr *EndIndex = static_cast<Expr *>(D.getArrayRangeEnd());
3214 Init.getAs<Expr>());
3938 Expr *Initializer = Args[0];
4149 Expr *Initializer,
4178 Expr *Initializer,
4221 Expr *Initializer = InitList->getInit(0);
4309 Expr *InitListAsExpr = InitList;
4318 Expr *SubInit[1] = {InitList->getInit(0)};
4366 Expr *InitListAsExpr = InitList;
4376 Expr *E = InitList->getInit(0);
4439 Expr *SubInit[1] = { InitList->getInit(0) };
4464 Expr *Initializer, bool AllowRValues, bool IsLValueRef,
4656 Expr *CurInitExpr);
4662 Expr *Initializer,
4687 static bool isNonReferenceableGLValue(Expr *E) {
4695 Expr *Initializer,
4710 Expr::Classification InitCategory = Initializer->Classify(S.Context);
5000 Expr *Initializer,
5069 Expr *InitListAsExpr = InitList;
5128 Expr *Initializer,
5308 const Expr *Init) {
5321 static InvalidICRKind isInvalidICRSource(ASTContext &C, Expr *e,
5379 return (e->isNullPointerConstant(C, Expr::NPC_ValueDependentIsNull)
5388 static void checkIndirectCopyRestoreSource(Sema &S, Expr *src) {
5425 Expr *Initializer) {
5472 Expr *Initializer) {
5482 static bool IsZeroInitializer(Expr *Initializer, Sema &S) {
5490 Expr *Initializer) {
5542 static bool isExprAnUnaddressableFunction(Sema &S, const Expr *E) {
5619 Expr::hasAnyTypeDependentArguments(Args)) {
5628 Expr *Initializer = nullptr;
5741 Expr *OVEAsExpr = &OVE;
6047 Expr *Initializer) {
6110 Expr *CurInitExpr = (Expr *)CurInit.get();
6171 SmallVector<Expr*, 8> ConstructorArgs;
6247 CurInit = S.MaybeBindToTemporary(CurInit.getAs<Expr>());
6256 Expr *CurInitExpr) {
6370 SmallVector<Expr*, 8> ConstructorArgs;
6644 using Local = Expr*;
6658 Expr *E;
6661 IndirectLocalPathEntry(EntryKind K, Expr *E) : Kind(K), E(E) {}
6662 IndirectLocalPathEntry(EntryKind K, Expr *E, const Decl *D)
6694 Expr *Init, LocalVisitor Visit,
6699 Expr *Init, ReferenceKind RK,
6784 static void handleGslAnnotatedTypes(IndirectLocalPath &Path, Expr *Call,
6845 static void visitLifetimeBoundArguments(IndirectLocalPath &Path, Expr *Call,
6848 ArrayRef<Expr*> Args;
6861 Expr *ObjectArg = nullptr;
6895 Expr *Init, ReferenceKind RK,
6901 Expr *Old;
7023 Expr *Init, LocalVisitor Visit,
7028 Expr *Old;
7166 Expr *SubInit = ILE->getInit(Index);
7188 for (Expr *E : LE->capture_inits()) {
7285 Expr *E) {
7319 Expr *Init) {
7577 const Expr *PostInit);
7580 static void CheckMoveOnConstruction(Sema &S, const Expr *InitExpr,
7610 const Expr *Arg = CE->getArg(0)->IgnoreImplicit();
7641 const Expr *ArgStripped = Arg->IgnoreImplicit()->IgnoreParens();
7677 static void CheckForNullPointerDereference(Sema &S, const Expr *E) {
7684 isNullPointerConstant(S.Context, Expr::NPC_ValueDependentIsNotNull)) {
7692 Sema::CreateMaterializeTemporaryExpr(QualType T, Expr *Temporary,
7707 ExprResult Sema::TemporaryMaterializationConversion(Expr *E) {
7725 ExprResult Sema::PerformQualificationConversion(Expr *E, QualType Ty,
7831 Expr *Init = Args[0];
7860 SmallVector<Expr*, 4> ArrayLoopCommonExprs;
8052 SmallVector<Expr*, 8> ConstructorArgs;
8057 Expr *Arg = CurInit.get();
8110 CurInit = S.MaybeBindToTemporary(CurInit.getAs<Expr>());
8260 Expr *E = CurInit.get();
8287 Expr *Source = CurInit.get();
8379 Expr *Cur = CurInit.get();
8380 Expr *BaseExpr = new (S.Context)
8383 Expr *IndexExpr =
8394 Expr *Common = ArrayLoopCommonExprs.pop_back_val();
8485 Expr *Init = CurInit.get()->IgnoreParens();
8530 Expr::EvalResult EVResult;
8575 if (auto *Init = CurInit.get())
8586 if (const Expr *E = CurInit.get()) {
8636 Expr *op) {
8691 ArrayRef<Expr *> Args) {
8697 Expr *OnlyArg;
9493 const Expr *PostInit) {
9587 Expr *InitE = Init.get();
9605 Expr *InitE = Init.get();
9692 if (Expr::hasAnyTypeDependentArguments(Inits)) {
9836 Expr *E = ListInit->getInit(0);
tools/clang/lib/Sema/SemaLambda.cpp 573 static EnumDecl *findEnumForBlockReturn(Expr *E) {
598 if (Expr *last = dyn_cast_or_null<Expr>(SE->getSubStmt()->body_back()))
598 if (Expr *last = dyn_cast_or_null<Expr>(SE->getSubStmt()->body_back()))
637 if (Expr *retValue = ret->getRetValue())
671 Expr *retValue = ret->getRetValue();
681 Expr *E = (cleanups ? cleanups->getSubExpr() : retValue);
760 const Expr *RetE = RS->getRetValue();
788 Expr *&Init) {
845 Init = Result.getAs<Expr>();
853 unsigned InitStyle, Expr *Init) {
1500 Expr *This = BuildCXXThisExpr(Loc, ThisTy, ImplicitCaptureLoc.isValid());
1522 Expr *InitExpr = Init.get();
1556 Expr *Init = From.getVariable()->getInit();
1649 SmallVector<Expr *, 4> CaptureInits;
1862 Expr *Src) {
1922 Expr *BuildBlock = new (Context) BlockExpr(Block, Conv->getConversionType());
tools/clang/lib/Sema/SemaLookup.cpp 2977 SourceLocation InstantiationLoc, ArrayRef<Expr *> Args,
2994 Expr *Arg = Args[ArgIdx];
3116 Expr *Arg = nullptr;
3188 Expr::Classification Classification =
3525 ArrayRef<Expr *> Args, ADLResult &Result) {
tools/clang/lib/Sema/SemaObjCProperty.cpp 1418 Expr *LoadSelfExpr =
1422 Expr *IvarRefExpr =
1434 Expr *ResExpr = Res.getAs<Expr>();
1434 Expr *ResExpr = Res.getAs<Expr>();
1470 Expr *LoadSelfExpr =
1474 Expr *lhs =
1490 Expr *callExpr = Res.getAs<Expr>();
1490 Expr *callExpr = Res.getAs<Expr>();
1503 PIDecl->setSetterCXXAssignment(Res.getAs<Expr>());
tools/clang/lib/Sema/SemaOpenMP.cpp 38 static const Expr *checkMapClauseExpressionBase(
39 Sema &SemaRef, Expr *E,
64 const Expr *RefExpr = nullptr;
69 const Expr *RefExpr, DeclRefExpr *PrivateCopy,
75 llvm::SmallVector<std::pair<Expr *, OverloadedOperatorKind>, 4>;
84 llvm::PointerIntPair<const Expr *, 1, bool> RefExpr;
88 using AlignedMapTy = llvm::SmallDenseMap<const ValueDecl *, const Expr *, 8>;
105 llvm::PointerUnion<const Expr *, BOKPtrType> ReductionOp;
111 void set(const Expr *RefExpr, SourceRange RR) {
140 llvm::Optional<std::pair<const Expr *, OMPOrderedClause *>> OrderedRegion;
150 Expr *TaskgroupReductionRef = nullptr;
261 Expr *OMPPredefinedAllocators[OMPAllocateDeclAttr::OMPUserDefinedMemAlloc] = {
275 Expr *Allocator) {
279 Expr *getAllocator(OMPAllocateDeclAttr::AllocatorTypeTy AllocatorKind) const {
418 const Expr *addUniqueAligned(const ValueDecl *D, const Expr *NewDE);
418 const Expr *addUniqueAligned(const ValueDecl *D, const Expr *NewDE);
437 void addDSA(const ValueDecl *D, const Expr *E, OpenMPClauseKind A,
447 const Expr *ReductionRef);
453 Expr *&TaskgroupDescriptor) const;
458 const Expr *&ReductionRef,
459 Expr *&TaskgroupDescriptor) const;
461 Expr *getTaskgroupReductionRef() const {
628 void setOrderedRegion(bool IsOrdered, const Expr *Param,
643 std::pair<const Expr *, OMPOrderedClause *> getOrderedRegionParam() const {
657 std::pair<const Expr *, OMPOrderedClause *>
860 static const Expr *getExprAsWritten(const Expr *E) {
860 static const Expr *getExprAsWritten(const Expr *E) {
875 static Expr *getExprAsWritten(Expr *E) {
875 static Expr *getExprAsWritten(Expr *E) {
1011 const Expr *DSAStackTy::addUniqueAligned(const ValueDecl *D,
1012 const Expr *NewDE) {
1067 void DSAStackTy::addDSA(const ValueDecl *D, const Expr *E, OpenMPClauseKind A,
1144 Expr *&TaskgroupReductionRef =
1155 const Expr *ReductionRef) {
1167 Expr *&TaskgroupReductionRef =
1179 Expr *&TaskgroupDescriptor) const {
1188 ReductionData.ReductionOp.is<const Expr *>())
1203 const ValueDecl *D, SourceRange &SR, const Expr *&ReductionRef,
1204 Expr *&TaskgroupDescriptor) const {
1213 !ReductionData.ReductionOp.is<const Expr *>())
1216 ReductionRef = ReductionData.ReductionOp.get<const Expr *>();
1704 void Sema::checkOpenMPDeviceExpr(const Expr *E) {
2158 SmallVector<Expr *, 8> PrivateCopies;
2159 for (Expr *DE : Clause->varlists()) {
2205 Expr *NumIterations, Sema &SemaRef,
2384 ArrayRef<Expr *> VarList) {
2423 Sema::CheckOMPThreadPrivateDecl(SourceLocation Loc, ArrayRef<Expr *> VarList) {
2424 SmallVector<Expr *, 8> Vars;
2425 for (Expr *RefExpr : VarList) {
2481 if (const Expr *Init = VD->getAnyInitializer()) {
2504 getAllocatorKind(Sema &S, DSAStackTy *Stack, Expr *Allocator) {
2512 const Expr *AE = Allocator->IgnoreParenImpCasts();
2516 const Expr *DefAllocator = Stack->getAllocator(AllocatorKind);
2529 Sema &S, DSAStackTy *Stack, Expr *RefExpr, VarDecl *VD,
2530 OMPAllocateDeclAttr::AllocatorTypeTy AllocatorKind, Expr *Allocator) {
2534 Expr *PrevAllocator = A->getAllocator();
2541 const Expr *AE = Allocator->IgnoreParenImpCasts();
2542 const Expr *PAE = PrevAllocator->IgnoreParenImpCasts();
2581 Expr *Allocator, SourceRange SR) {
2597 SourceLocation Loc, ArrayRef<Expr *> VarList,
2600 Expr *Allocator = nullptr;
2614 SmallVector<Expr *, 8> Vars;
2615 for (Expr *RefExpr : VarList) {
2772 llvm::SmallVector<Expr *, 4> ImplicitFirstprivate;
2773 llvm::SmallVector<Expr *, 4> ImplicitMap;
3072 ArrayRef<Expr *> getImplicitFirstprivate() const {
3075 ArrayRef<Expr *> getImplicitMap() const { return ImplicitMap; }
3505 Expr *CaptureExpr, bool WithInit,
3509 Expr *Init = AsExpression ? CaptureExpr : CaptureExpr->IgnoreImpCasts();
3533 static DeclRefExpr *buildCapture(Sema &S, ValueDecl *D, Expr *CaptureExpr,
3657 for (Expr *E : IRC->taskgroup_descriptors())
3669 if (auto *E = cast_or_null<Expr>(VarRef)) {
3669 if (auto *E = cast_or_null<Expr>(VarRef)) {
3679 if (Expr *E = C->getPostUpdateExpr())
4072 getPrivateItem(Sema &S, Expr *&RefExpr, SourceLocation &ELoc,
4091 Expr *Base = ASE->getBase()->IgnoreParenImpCasts();
4097 Expr *Base = OASE->getBase()->IgnoreParenImpCasts();
4143 MutableArrayRef<Expr *>::iterator I, It, Et;
4182 for (Expr *E : llvm::make_range(It, Et)) {
4189 Expr *SimpleRefExpr = E;
4212 for (Expr *E : AC->varlists()) {
4215 Expr *SimpleRefExpr = E;
4275 SmallVector<Expr *, 4> ImplicitFirstprivates(
4278 SmallVector<Expr *, 4> ImplicitMaps(DSAChecker.getImplicitMap().begin(),
4283 for (Expr *E : IRC->taskgroup_descriptors())
4710 DeclGroupPtrTy DG, OMPDeclareSimdDeclAttr::BranchStateTy BS, Expr *Simdlen,
4711 ArrayRef<Expr *> Uniforms, ArrayRef<Expr *> Aligneds,
4711 ArrayRef<Expr *> Uniforms, ArrayRef<Expr *> Aligneds,
4712 ArrayRef<Expr *> Alignments, ArrayRef<Expr *> Linears,
4712 ArrayRef<Expr *> Alignments, ArrayRef<Expr *> Linears,
4713 ArrayRef<unsigned> LinModifiers, ArrayRef<Expr *> Steps, SourceRange SR) {
4748 llvm::DenseMap<const Decl *, const Expr *> UniformedArgs;
4749 const Expr *UniformedLinearThis = nullptr;
4750 for (const Expr *E : Uniforms) {
4775 llvm::DenseMap<const Decl *, const Expr *> AlignedArgs;
4776 const Expr *AlignedThis = nullptr;
4777 for (const Expr *E : Aligneds) {
4826 SmallVector<const Expr *, 4> NewAligns;
4827 for (Expr *E : Alignments) {
4842 llvm::DenseMap<const Decl *, const Expr *> LinearArgs;
4845 for (const Expr *E : Linears) {
4908 Expr *Step = nullptr;
4909 Expr *NewStep = nullptr;
4910 SmallVector<Expr *, 4> NewSteps;
4911 for (Expr *E : Steps) {
4957 Optional<std::pair<FunctionDecl *, Expr *>>
4959 Expr *VariantRef, SourceRange SR) {
5064 Expr *PossibleAddrOfVariantRef = VariantRefCast.get();
5168 return std::make_pair(FD, cast<Expr>(DRE));
5172 FunctionDecl *FD, Expr *VariantRef, SourceRange SR,
5177 Expr *Score = nullptr;
5206 Expr *VariantRef = A->getVariantFuncRef();
5244 Expr *PreCond = nullptr;
5247 Expr *NumIterations = nullptr;
5249 Expr *CounterVar = nullptr;
5251 Expr *PrivateCounterVar = nullptr;
5253 Expr *CounterInit = nullptr;
5256 Expr *CounterStep = nullptr;
5268 Expr *MinValue = nullptr;
5272 Expr *MaxValue = nullptr;
5283 Expr *FinalCondition = nullptr;
5307 Expr *LCRef = nullptr;
5309 Expr *LB = nullptr;
5311 Expr *UB = nullptr;
5313 Expr *Step = nullptr;
5337 Expr *Condition = nullptr;
5349 bool checkAndSetCond(Expr *S);
5352 bool checkAndSetInc(Expr *S);
5356 Expr *getLoopDeclRefExpr() const { return LCRef; }
5368 Expr *buildNumIterations(
5370 llvm::MapVector<const Expr *, DeclRefExpr *> &Captures) const;
5372 Expr *
5373 buildPreCond(Scope *S, Expr *Cond,
5374 llvm::MapVector<const Expr *, DeclRefExpr *> &Captures) const;
5377 buildCounterVar(llvm::MapVector<const Expr *, DeclRefExpr *> &Captures,
5381 Expr *buildPrivateCounterVar() const;
5383 Expr *buildCounterInit() const;
5385 Expr *buildCounterStep() const;
5388 Expr *
5389 buildOrderedLoopData(Scope *S, Expr *Counter,
5390 llvm::MapVector<const Expr *, DeclRefExpr *> &Captures,
5391 SourceLocation Loc, Expr *Inc = nullptr,
5394 std::pair<Expr *, Expr *> buildMinMaxValues(
5394 std::pair<Expr *, Expr *> buildMinMaxValues(
5395 Scope *S, llvm::MapVector<const Expr *, DeclRefExpr *> &Captures) const;
5397 Expr *buildFinalCondition(Scope *S) const;
5412 bool checkAndSetIncRHS(Expr *RHS);
5414 bool setLCDeclAndLB(ValueDecl *NewLCDecl, Expr *NewDeclRefExpr, Expr *NewLB,
5414 bool setLCDeclAndLB(ValueDecl *NewLCDecl, Expr *NewDeclRefExpr, Expr *NewLB,
5417 bool setUB(Expr *NewUB, llvm::Optional<bool> LessOp, bool StrictOp,
5420 bool setStep(Expr *NewStep, bool Subtract);
5434 Expr *NewLCRefExpr,
5435 Expr *NewLB, bool EmitDiags) {
5455 bool OpenMPIterationSpaceChecker::setUB(Expr *NewUB,
5474 bool OpenMPIterationSpaceChecker::setStep(Expr *NewStep, bool Subtract) {
5548 bool checkDecl(const Expr *E, const ValueDecl *VD) {
5660 if (Expr *E = dyn_cast<Expr>(S))
5660 if (Expr *E = dyn_cast<Expr>(S))
5664 Expr *LHS = BO->getLHS()->IgnoreParens();
5699 Expr *LHS = CE->getArg(0);
5727 static const ValueDecl *getInitLCDecl(const Expr *E) {
5747 bool OpenMPIterationSpaceChecker::checkAndSetCond(Expr *S) {
5817 bool OpenMPIterationSpaceChecker::checkAndSetIncRHS(Expr *RHS) {
5848 bool OpenMPIterationSpaceChecker::checkAndSetInc(Expr *S) {
5931 if (Capture->isEvaluatable(SemaRef.Context, Expr::SE_AllowSideEffects))
5945 Expr *OpenMPIterationSpaceChecker::buildNumIterations(
5947 llvm::MapVector<const Expr *, DeclRefExpr *> &Captures) const {
5952 Expr *LBVal = LB;
5953 Expr *UBVal = UB;
6003 Expr *LBMin = tryBuildCapture(SemaRef, LBMinVal.get(), Captures).get();
6004 Expr *LBMax = tryBuildCapture(SemaRef, LBMaxVal.get(), Captures).get();
6012 Expr *MinLessMax =
6083 Expr *UBMin = tryBuildCapture(SemaRef, UBMinVal.get(), Captures).get();
6084 Expr *UBMax = tryBuildCapture(SemaRef, UBMaxVal.get(), Captures).get();
6092 Expr *MinGreaterMax =
6115 Expr *UBExpr = TestIsLessOp.getValue() ? UBVal : LBVal;
6116 Expr *LBExpr = TestIsLessOp.getValue() ? LBVal : UBVal;
6117 Expr *Upper = tryBuildCapture(SemaRef, UBExpr, Captures).get();
6118 Expr *Lower = tryBuildCapture(SemaRef, LBExpr, Captures).get();
6203 std::pair<Expr *, Expr *> OpenMPIterationSpaceChecker::buildMinMaxValues(
6203 std::pair<Expr *, Expr *> OpenMPIterationSpaceChecker::buildMinMaxValues(
6204 Scope *S, llvm::MapVector<const Expr *, DeclRefExpr *> &Captures) const {
6211 Expr *MinExpr = nullptr;
6212 Expr *MaxExpr = nullptr;
6213 Expr *LBExpr = TestIsLessOp.getValue() ? LB : UB;
6214 Expr *UBExpr = TestIsLessOp.getValue() ? UB : LB;
6219 Expr *Lower =
6221 Expr *Upper =
6318 Expr *OpenMPIterationSpaceChecker::buildFinalCondition(Scope *S) const {
6324 Expr *OpenMPIterationSpaceChecker::buildPreCond(
6325 Scope *S, Expr *Cond,
6326 llvm::MapVector<const Expr *, DeclRefExpr *> &Captures) const {
6365 llvm::MapVector<const Expr *, DeclRefExpr *> &Captures,
6383 Expr *OpenMPIterationSpaceChecker::buildPrivateCounterVar() const {
6400 Expr *OpenMPIterationSpaceChecker::buildCounterInit() const { return LB; }
6403 Expr *OpenMPIterationSpaceChecker::buildCounterStep() const { return Step; }
6405 Expr *OpenMPIterationSpaceChecker::buildOrderedLoopData(
6406 Scope *S, Expr *Counter,
6407 llvm::MapVector<const Expr *, DeclRefExpr *> &Captures, SourceLocation Loc,
6408 Expr *Inc, OverloadedOperatorKind OOK) {
6409 Expr *Cnt = SemaRef.DefaultLvalueConversion(Counter).get();
6425 Expr *Upper = TestIsLessOp.getValue()
6428 Expr *Lower = TestIsLessOp.getValue()
6508 Expr *LoopDeclRefExpr = ISC.getLoopDeclRefExpr();
6552 unsigned TotalNestedLoopCount, Expr *CollapseLoopCountExpr,
6553 Expr *OrderedLoopCountExpr,
6556 llvm::MapVector<const Expr *, DeclRefExpr *> &Captures) {
6702 Expr *CntValue;
6840 static bool fitsInto(unsigned Bits, bool Signed, const Expr *E, Sema &SemaRef) {
6863 const llvm::MapVector<const Expr *, DeclRefExpr *> &Captures) {
6874 static Expr *buildPostUpdate(Sema &S, ArrayRef<Expr *> PostUpdates) {
6874 static Expr *buildPostUpdate(Sema &S, ArrayRef<Expr *> PostUpdates) {
6875 Expr *PostUpdate = nullptr;
6877 for (Expr *E : PostUpdates) {
6878 Expr *ConvE = S.BuildCStyleCastExpr(
6897 checkOpenMPLoop(OpenMPDirectiveKind DKind, Expr *CollapseLoopCountExpr,
6898 Expr *OrderedLoopCountExpr, Stmt *AStmt, Sema &SemaRef,
6905 Expr::EvalResult Result;
6917 Expr::EvalResult EVResult;
6938 llvm::MapVector<const Expr *, DeclRefExpr *> Captures;
7027 Expr *N0 = IterSpaces[0].NumIterations;
7058 Expr *N = IterSpaces[Cnt].NumIterations;
7236 Expr *RHS =
7245 Expr *CombRHS =
7266 Expr *BoundUB = UB.get();
7292 Expr *BoundCombUB = CombUB.get();
7411 Expr *BoundPrevUB = PrevUB.get();
7584 static Expr *getCollapseNumberExpr(ArrayRef<OMPClause *> Clauses) {
7592 static Expr *getOrderedNumberExpr(ArrayRef<OMPClause *> Clauses) {
7615 const Expr *SimdlenLength = Simdlen->getSimdlen();
7616 const Expr *SafelenLength = Safelen->getSafelen();
7625 Expr::EvalResult SimdlenResult, SafelenResult;
7873 Expr *E = cast<OMPHintClause>(C)->getHint();
8155 if (const Expr *Param = DSAStack->getParentOrderedRegionParam().first) {
8207 Expr *X;
8209 Expr *E;
8213 Expr *UpdateExpr;
8236 Expr *getX() const { return X; }
8238 Expr *getExpr() const { return E; }
8242 Expr *getUpdateExpr() const { return UpdateExpr; }
8274 Expr *LHS = AtomicInnerBinOp->getLHS();
8275 Expr *RHS = AtomicInnerBinOp->getRHS();
8338 if (auto *AtomicBody = dyn_cast<Expr>(S)) {
8338 if (auto *AtomicBody = dyn_cast<Expr>(S)) {
8452 Expr *X = nullptr;
8453 Expr *V = nullptr;
8454 Expr *E = nullptr;
8455 Expr *UE = nullptr;
8492 if (const auto *AtomicBody = dyn_cast<Expr>(Body)) {
8492 if (const auto *AtomicBody = dyn_cast<Expr>(Body)) {
8501 const Expr *NotLValueExpr = X->isLValue() ? V : X;
8510 const Expr *NotScalarExpr =
8555 if (const auto *AtomicBody = dyn_cast<Expr>(Body)) {
8555 if (const auto *AtomicBody = dyn_cast<Expr>(Body)) {
8572 const Expr *NotScalarExpr =
8637 if (const auto *AtomicBody = dyn_cast<Expr>(Body)) {
8637 if (const auto *AtomicBody = dyn_cast<Expr>(Body)) {
8721 Expr *PossibleX = BinOp->getRHS()->IgnoreParenImpCasts();
8751 Expr *PossibleX = BinOp->getRHS()->IgnoreParenImpCasts();
8768 auto *FirstExpr = dyn_cast<Expr>(First);
8768 auto *FirstExpr = dyn_cast<Expr>(First);
8769 auto *SecondExpr = dyn_cast<Expr>(Second);
8769 auto *SecondExpr = dyn_cast<Expr>(Second);
8792 Expr *PossibleXRHSInFirst =
8794 Expr *PossibleXLHSInSecond =
10230 OMPClause *Sema::ActOnOpenMPSingleExprClause(OpenMPClauseKind Kind, Expr *Expr,
10973 Expr *Condition, SourceLocation StartLoc,
10978 Expr *ValExpr = Condition;
10995 llvm::MapVector<const Expr *, DeclRefExpr *> Captures;
11006 OMPClause *Sema::ActOnOpenMPFinalClause(Expr *Condition,
11010 Expr *ValExpr = Condition;
11026 llvm::MapVector<const Expr *, DeclRefExpr *> Captures;
11081 isNonNegativeIntegerValue(Expr *&ValExpr, Sema &SemaRef, OpenMPClauseKind CKind,
11112 llvm::MapVector<const Expr *, DeclRefExpr *> Captures;
11120 OMPClause *Sema::ActOnOpenMPNumThreadsClause(Expr *NumThreads,
11124 Expr *ValExpr = NumThreads;
11138 llvm::MapVector<const Expr *, DeclRefExpr *> Captures;
11178 OMPClause *Sema::ActOnOpenMPSafelenClause(Expr *Len, SourceLocation StartLoc,
11191 OMPClause *Sema::ActOnOpenMPSimdlenClause(Expr *Len, SourceLocation StartLoc,
11248 OMPClause *Sema::ActOnOpenMPAllocatorClause(Expr *A, SourceLocation StartLoc,
11269 OMPClause *Sema::ActOnOpenMPCollapseClause(Expr *NumForLoops,
11289 Expr *NumForLoops) {
11476 OpenMPClauseKind Kind, ArrayRef<unsigned> Argument, Expr *Expr,
11597 OpenMPScheduleClauseKind Kind, Expr *ChunkSize, SourceLocation StartLoc,
11641 Expr *ValExpr = ChunkSize;
11670 llvm::MapVector<const Expr *, DeclRefExpr *> Captures;
11861 OpenMPClauseKind Kind, ArrayRef<Expr *> VarList, Expr *TailExpr,
11861 OpenMPClauseKind Kind, ArrayRef<Expr *> VarList, Expr *TailExpr,
12011 OMPClause *Sema::ActOnOpenMPPrivateClause(ArrayRef<Expr *> VarList,
12015 SmallVector<Expr *, 8> Vars;
12016 SmallVector<Expr *, 8> PrivateCopies;
12017 for (Expr *RefExpr : VarList) {
12021 Expr *SimpleRefExpr = RefExpr;
12171 OMPClause *Sema::ActOnOpenMPFirstprivateClause(ArrayRef<Expr *> VarList,
12175 SmallVector<Expr *, 8> Vars;
12176 SmallVector<Expr *, 8> PrivateCopies;
12177 SmallVector<Expr *, 8> Inits;
12183 for (Expr *RefExpr : VarList) {
12187 Expr *SimpleRefExpr = RefExpr;
12380 Expr *VDInitRefExpr = nullptr;
12387 Expr *Init = DefaultLvalueConversion(VDInitRefExpr).get();
12400 VDPrivate->setInit(Result.getAs<Expr>());
12449 OMPClause *Sema::ActOnOpenMPLastprivateClause(ArrayRef<Expr *> VarList,
12453 SmallVector<Expr *, 8> Vars;
12454 SmallVector<Expr *, 8> SrcExprs;
12455 SmallVector<Expr *, 8> DstExprs;
12456 SmallVector<Expr *, 8> AssignmentOps;
12458 SmallVector<Expr *, 4> ExprPostUpdates;
12459 for (Expr *RefExpr : VarList) {
12463 Expr *SimpleRefExpr = RefExpr;
12610 OMPClause *Sema::ActOnOpenMPSharedClause(ArrayRef<Expr *> VarList,
12614 SmallVector<Expr *, 8> Vars;
12615 for (Expr *RefExpr : VarList) {
12619 Expr *SimpleRefExpr = RefExpr;
12933 SmallVector<Expr *, 8> Vars;
12935 SmallVector<Expr *, 8> Privates;
12937 SmallVector<Expr *, 8> LHSs;
12939 SmallVector<Expr *, 8> RHSs;
12941 SmallVector<Expr *, 8> ReductionOps;
12944 SmallVector<Expr *, 8> TaskgroupDescriptors;
12948 SmallVector<Expr *, 4> ExprPostUpdates;
12963 void push(Expr *Item, Expr *ReductionOp) {
12963 void push(Expr *Item, Expr *ReductionOp) {
12972 void push(Expr *Item, Expr *Private, Expr *LHS, Expr *RHS, Expr *ReductionOp,
12972 void push(Expr *Item, Expr *Private, Expr *LHS, Expr *RHS, Expr *ReductionOp,
12972 void push(Expr *Item, Expr *Private, Expr *LHS, Expr *RHS, Expr *ReductionOp,
12972 void push(Expr *Item, Expr *Private, Expr *LHS, Expr *RHS, Expr *ReductionOp,
12972 void push(Expr *Item, Expr *Private, Expr *LHS, Expr *RHS, Expr *ReductionOp,
12973 Expr *TaskgroupDescriptor) {
12987 const Expr *Length = OASE->getLength();
12998 Expr::EvalResult Result;
13008 const Expr *Base = OASE->getBase()->IgnoreParenImpCasts();
13023 Expr::EvalResult Result;
13052 ArrayRef<Expr *> VarList, SourceLocation StartLoc, SourceLocation LParenLoc,
13055 ArrayRef<Expr *> UnresolvedReductions, ReductionData &RD) {
13148 for (Expr *RefExpr : VarList) {
13162 Expr *SimpleRefExpr = RefExpr;
13173 Expr *ReductionOp = nullptr;
13185 Expr *TaskgroupDescriptor = nullptr;
13397 Expr *Init = nullptr;
13554 Expr *Args[] = {LHS.get(), RHS.get()};
13591 const Expr *ParentReductionOp;
13592 Expr *ParentBOKTD, *ParentReductionOpTD;
13634 Expr *VarsExpr = RefExpr->IgnoreParens();
13684 ArrayRef<Expr *> VarList, SourceLocation StartLoc, SourceLocation LParenLoc,
13687 ArrayRef<Expr *> UnresolvedReductions) {
13704 ArrayRef<Expr *> VarList, SourceLocation StartLoc, SourceLocation LParenLoc,
13707 ArrayRef<Expr *> UnresolvedReductions) {
13724 ArrayRef<Expr *> VarList, SourceLocation StartLoc, SourceLocation LParenLoc,
13727 ArrayRef<Expr *> UnresolvedReductions) {
13795 ArrayRef<Expr *> VarList, Expr *Step, SourceLocation StartLoc,
13795 ArrayRef<Expr *> VarList, Expr *Step, SourceLocation StartLoc,
13798 SmallVector<Expr *, 8> Vars;
13799 SmallVector<Expr *, 8> Privates;
13800 SmallVector<Expr *, 8> Inits;
13802 SmallVector<Expr *, 4> ExprPostUpdates;
13805 for (Expr *RefExpr : VarList) {
13809 Expr *SimpleRefExpr = RefExpr;
13848 Expr *InitExpr;
13887 Expr *StepExpr = Step;
13888 Expr *CalcStepExpr = nullptr;
13929 Expr *NumIterations, Sema &SemaRef,
13932 SmallVector<Expr *, 8> Updates;
13933 SmallVector<Expr *, 8> Finals;
13934 SmallVector<Expr *, 8> UsedExprs;
13935 Expr *Step = Clause.getStep();
13936 Expr *CalcStep = Clause.getCalcStep();
13947 for (Expr *RefExpr : Clause.varlists()) {
13950 Expr *SimpleRefExpr = RefExpr;
13972 Expr *InitExpr = *CurInit;
13976 Expr *CapturedRef;
14022 if (Expr *S = Clause.getStep())
14033 ArrayRef<Expr *> VarList, Expr *Alignment, SourceLocation StartLoc,
14033 ArrayRef<Expr *> VarList, Expr *Alignment, SourceLocation StartLoc,
14035 SmallVector<Expr *, 8> Vars;
14036 for (Expr *RefExpr : VarList) {
14040 Expr *SimpleRefExpr = RefExpr;
14072 if (const Expr *PrevRef = DSAStack->addUniqueAligned(D, SimpleRefExpr)) {
14106 OMPClause *Sema::ActOnOpenMPCopyinClause(ArrayRef<Expr *> VarList,
14110 SmallVector<Expr *, 8> Vars;
14111 SmallVector<Expr *, 8> SrcExprs;
14112 SmallVector<Expr *, 8> DstExprs;
14113 SmallVector<Expr *, 8> AssignmentOps;
14114 for (Expr *RefExpr : VarList) {
14200 OMPClause *Sema::ActOnOpenMPCopyprivateClause(ArrayRef<Expr *> VarList,
14204 SmallVector<Expr *, 8> Vars;
14205 SmallVector<Expr *, 8> SrcExprs;
14206 SmallVector<Expr *, 8> DstExprs;
14207 SmallVector<Expr *, 8> AssignmentOps;
14208 for (Expr *RefExpr : VarList) {
14212 Expr *SimpleRefExpr = RefExpr;
14313 OMPClause *Sema::ActOnOpenMPFlushClause(ArrayRef<Expr *> VarList,
14326 ArrayRef<Expr *> VarList, SourceLocation StartLoc,
14344 SmallVector<Expr *, 8> Vars;
14349 if (const Expr *OrderedCountExpr =
14355 for (Expr *RefExpr : VarList) {
14364 Expr *SimpleExpr = RefExpr->IgnoreParenCasts();
14388 Expr *LHS = SimpleExpr;
14389 Expr *RHS = nullptr;
14489 OMPClause *Sema::ActOnOpenMPDeviceClause(Expr *Device, SourceLocation StartLoc,
14492 Expr *ValExpr = Device;
14506 llvm::MapVector<const Expr *, DeclRefExpr *> Captures;
14533 const Expr *E,
14548 const Expr *LowerBound = OASE->getLowerBound();
14549 const Expr *Length = OASE->getLength();
14554 Expr::EvalResult Result;
14578 Expr::EvalResult Result;
14590 const Expr *E,
14600 const Expr *Length = OASE->getLength();
14613 Expr::EvalResult Result;
14625 static const Expr *checkMapClauseExpressionBase(
14626 Sema &SemaRef, Expr *E,
14651 const Expr *RelevantExpr = nullptr;
14690 Expr *BaseE = CurE->getBase()->IgnoreParenImpCasts();
14775 Expr::EvalResult Result;
14834 Expr::EvalResult ResultR;
14835 Expr::EvalResult ResultL;
14876 Sema &SemaRef, DSAStackTy *DSAS, const ValueDecl *VD, const Expr *E,
14894 const Expr *EnclosingExpr = nullptr;
14910 const Expr *RE = StackComponents.front().getAssociatedExpression();
14958 const Expr *E = OASE->getBase()->IgnoreParenImpCasts();
15231 ArrayRef<Expr *> VarList;
15233 SmallVector<Expr *, 16> ProcessedVarList;
15239 SmallVector<Expr *, 16> UDMapperList;
15241 MappableVarListInfo(ArrayRef<Expr *> VarList) : VarList(VarList) {
15260 ArrayRef<Expr *> UnresolvedMappers,
15280 Expr *UnresolvedMapper = nullptr;
15288 for (Expr *RE : MVLI.VarList) {
15303 const Expr *VE = RE->IgnoreParenLValueCasts();
15321 Expr *SimpleExpr = RE->IgnoreParenCasts();
15335 const Expr *BE = checkMapClauseExpressionBase(
15510 SourceLocation ColonLoc, ArrayRef<Expr *> VarList,
15511 const OMPVarListLocTy &Locs, ArrayRef<Expr *> UnresolvedMappers) {
15700 Expr *InE =
15702 Expr *OutE =
15707 void Sema::ActOnOpenMPDeclareReductionCombinerEnd(Decl *D, Expr *Combiner) {
15760 Expr *OrigE =
15762 Expr *PrivE =
15768 void Sema::ActOnOpenMPDeclareReductionInitializerEnd(Decl *D, Expr *Initializer,
15921 Expr *MapperVarRefExpr = buildDeclRefExpr(*this, VD, MapperType, StartLoc);
15940 OMPClause *Sema::ActOnOpenMPNumTeamsClause(Expr *NumTeams,
15944 Expr *ValExpr = NumTeams;
15958 llvm::MapVector<const Expr *, DeclRefExpr *> Captures;
15967 OMPClause *Sema::ActOnOpenMPThreadLimitClause(Expr *ThreadLimit,
15971 Expr *ValExpr = ThreadLimit;
15985 llvm::MapVector<const Expr *, DeclRefExpr *> Captures;
15994 OMPClause *Sema::ActOnOpenMPPriorityClause(Expr *Priority,
15998 Expr *ValExpr = Priority;
16014 OMPClause *Sema::ActOnOpenMPGrainsizeClause(Expr *Grainsize,
16018 Expr *ValExpr = Grainsize;
16035 OMPClause *Sema::ActOnOpenMPNumTasksClause(Expr *NumTasks,
16039 Expr *ValExpr = NumTasks;
16056 OMPClause *Sema::ActOnOpenMPHintClause(Expr *Hint, SourceLocation StartLoc,
16070 OpenMPDistScheduleClauseKind Kind, Expr *ChunkSize, SourceLocation StartLoc,
16082 Expr *ValExpr = ChunkSize;
16111 llvm::MapVector<const Expr *, DeclRefExpr *> Captures;
16286 void Sema::checkDeclIsAllowedInOpenMPTarget(Expr *E, Decl *D,
16350 OMPClause *Sema::ActOnOpenMPToClause(ArrayRef<Expr *> VarList,
16354 ArrayRef<Expr *> UnresolvedMappers) {
16367 OMPClause *Sema::ActOnOpenMPFromClause(ArrayRef<Expr *> VarList,
16371 ArrayRef<Expr *> UnresolvedMappers) {
16384 OMPClause *Sema::ActOnOpenMPUseDevicePtrClause(ArrayRef<Expr *> VarList,
16387 SmallVector<Expr *, 8> PrivateCopies;
16388 SmallVector<Expr *, 8> Inits;
16390 for (Expr *RefExpr : VarList) {
16394 Expr *SimpleRefExpr = RefExpr;
16469 OMPClause *Sema::ActOnOpenMPIsDevicePtrClause(ArrayRef<Expr *> VarList,
16472 for (Expr *RefExpr : VarList) {
16476 Expr *SimpleRefExpr = RefExpr;
16507 const Expr *ConflictExpr;
16552 Expr *Allocator, ArrayRef<Expr *> VarList, SourceLocation StartLoc,
16552 Expr *Allocator, ArrayRef<Expr *> VarList, SourceLocation StartLoc,
16581 SmallVector<Expr *, 8> Vars;
16582 for (Expr *RefExpr : VarList) {
16586 Expr *SimpleRefExpr = RefExpr;
tools/clang/lib/Sema/SemaOverload.cpp 50 const Expr *Base, bool HadMultipleCandidates,
75 static bool IsStandardConversion(Sema &S, Expr* From, QualType ToType,
81 static bool IsTransparentUnionStandardConversion(Sema &S, Expr* From,
87 IsUserDefinedConversion(Sema &S, Expr *From, QualType ToType,
260 static const Expr *IgnoreNarrowingConversion(ASTContext &Ctx,
261 const Expr *Converted) {
265 Expr *Inner =
304 ASTContext &Ctx, const Expr *Converted, APValue &ConstantValue,
345 const Expr *Initializer = IgnoreNarrowingConversion(Ctx, Converted);
383 const Expr *Initializer = IgnoreNarrowingConversion(Ctx, Converted);
429 const Expr *Initializer = IgnoreNarrowingConversion(Ctx, Converted);
891 Expr **Addr;
892 Expr *Saved;
897 void save(Sema &S, Expr *&E) {
920 checkPlaceholderForOverload(Sema &S, Expr *&E,
1267 TryUserDefinedConversion(Sema &S, Expr *From, QualType ToType,
1370 TryImplicitConversion(Sema &S, Expr *From, QualType ToType,
1425 Sema::TryImplicitConversion(Expr *From, QualType ToType,
1444 Sema::PerformImplicitConversion(Expr *From, QualType ToType,
1451 Sema::PerformImplicitConversion(Expr *From, QualType ToType,
1616 static bool tryAtomicConversion(Sema &S, Expr *From, QualType ToType,
1629 static bool IsStandardConversion(Sema &S, Expr* From, QualType ToType,
1972 IsTransparentUnionStandardConversion(Sema &S, Expr* From,
1998 bool Sema::IsIntegralPromotion(Expr *From, QualType FromType, QualType ToType) {
2257 static bool isNullPointerConstantForConversion(Expr *Expr,
2267 InOverloadResolution? Expr::NPC_ValueDependentIsNotNull
2268 : Expr::NPC_ValueDependentIsNull);
2287 bool Sema::IsPointerConversion(Expr *From, QualType FromType, QualType ToType,
2917 bool Sema::CheckPointerConversion(Expr *From, QualType ToType,
2928 From->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNotNull) ==
2929 Expr::NPCK_ZeroExpression) {
2992 if (From->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull))
3003 bool Sema::IsMemberPointerConversion(Expr *From, QualType FromType,
3013 InOverloadResolution? Expr::NPC_ValueDependentIsNotNull
3014 : Expr::NPC_ValueDependentIsNull)) {
3045 bool Sema::CheckMemberPointerConversion(Expr *From, QualType ToType,
3219 static bool tryAtomicConversion(Sema &S, Expr *From, QualType ToType,
3256 IsInitializerListConstructorConversion(Sema &S, Expr *From, QualType ToType,
3333 IsUserDefinedConversion(Sema &S, Expr *From, QualType ToType,
3365 Expr **Args = &From;
3538 Sema::DiagnoseMultipleUserDefinedConversion(Expr *From, QualType ToType) {
4467 Expr *Init, QualType T2, bool AllowRvalues,
4594 TryReferenceInit(Sema &S, Expr *Init, QualType DeclType,
4623 Expr::Classification InitCategory = Init->Classify(S.Context);
4862 TryCopyInitialization(Sema &S, Expr *From, QualType ToType,
4946 Expr *Init = From->getInit(i);
5033 Expr *Init = From->getInit(0);
5127 TryCopyInitialization(Sema &S, Expr *From, QualType ToType,
5167 Expr::Classification FromClassification,
5293 Sema::PerformObjectArgumentInitialization(Expr *From,
5301 Expr::Classification FromClassification;
5305 FromClassification = Expr::Classification::makeSimpleLValue();
5385 TryContextuallyConvertToBool(Sema &S, Expr *From) {
5397 ExprResult Sema::PerformContextuallyConvertToBool(Expr *From) {
5480 static ExprResult CheckConvertedConstantExpression(Sema &S, Expr *From,
5588 Expr::EvalResult Eval;
5590 Expr::ConstExprUsage Usage = CCE == Sema::CCEK_TemplateArg
5591 ? Expr::EvaluateForMangling
5592 : Expr::EvaluateForCodeGen;
5621 ExprResult Sema::CheckConvertedConstantExpression(Expr *From, QualType T,
5626 ExprResult Sema::CheckConvertedConstantExpression(Expr *From, QualType T,
5653 TryContextuallyConvertToObjCPointer(Sema &S, Expr *From) {
5688 ExprResult Sema::PerformContextuallyConvertToObjCPointer(Expr *From) {
5708 diagnoseAmbiguousConversion(Sema &SemaRef, SourceLocation Loc, Expr *From,
5726 diagnoseNoViableConversion(Sema &SemaRef, SourceLocation Loc, Expr *&From,
5766 static bool recordConversion(Sema &SemaRef, SourceLocation Loc, Expr *&From,
5795 Sema &SemaRef, SourceLocation Loc, Expr *From,
5805 collectViableConversionCandidates(Sema &SemaRef, Expr *From, QualType ToType,
5853 SourceLocation Loc, Expr *From, ContextualImplicitConverter &Converter) {
5885 Expr *From;
5887 TypeDiagnoserPartialDiag(ContextualImplicitConverter &Converter, Expr *From)
6042 ArrayRef<Expr *> Args) {
6083 FunctionDecl *Function, DeclAccessPair FoundDecl, ArrayRef<Expr *> Args,
6104 Expr::Classification::makeSimpleLValue(), Args,
6323 Expr *argExpr = Args[i];
6391 convertArgsForAvailabilityChecks(Sema &S, FunctionDecl *Function, Expr *ThisArg,
6392 ArrayRef<Expr *> Args, Sema::SFINAETrap &Trap,
6393 bool MissingImplicitThis, Expr *&ConvertedThis,
6394 SmallVectorImpl<Expr *> &ConvertedArgs) {
6439 Expr *DefArg = P->hasUninstantiatedDefaultArg()
6461 EnableIfAttr *Sema::CheckEnableIf(FunctionDecl *Function, ArrayRef<Expr *> Args,
6468 SmallVector<Expr *, 16> ConvertedArgs;
6470 Expr *DiscardedThis;
6532 const Expr *ThisArg,
6533 ArrayRef<const Expr *> Args,
6563 ArrayRef<Expr *> Args,
6571 ArrayRef<Expr *> FunctionArgs = Args;
6579 Expr::Classification ObjectClassification;
6581 if (Expr *E = Args[0]) {
6587 ObjectClassification = Expr::Classification::makeSimpleLValue();
6633 Expr::Classification ObjectClassification,
6634 ArrayRef<Expr *> Args,
6668 Expr::Classification ObjectClassification,
6669 ArrayRef<Expr *> Args,
6813 Expr::Classification ObjectClassification, ArrayRef<Expr *> Args,
6813 Expr::Classification ObjectClassification, ArrayRef<Expr *> Args,
6877 TemplateArgumentListInfo *ExplicitTemplateArgs, ArrayRef<Expr *> Args,
6942 ArrayRef<Expr *> Args, OverloadCandidateSet &CandidateSet,
6945 Expr::Classification ObjectClassification, OverloadCandidateParamOrder PO) {
7045 CXXRecordDecl *ActingContext, Expr *From, QualType ToType,
7150 ExprValueKind VK = Expr::getValueKindForType(ConversionType);
7233 CXXRecordDecl *ActingDC, Expr *From, QualType ToType,
7277 Expr *Object,
7278 ArrayRef<Expr *> Args,
7381 const UnresolvedSetImpl &Fns, ArrayRef<Expr *> Args,
7386 ArrayRef<Expr *> FunctionArgs = Args;
7430 ArrayRef<Expr *> Args,
7479 void Sema::AddBuiltinCandidate(QualType *ParamTys, ArrayRef<Expr *> Args,
7822 Expr *Arg) {
7831 ArrayRef<Expr *> Args,
7855 static Qualifiers CollectVRQualifiers(ASTContext &Context, Expr* ArgExpr) {
7913 ArrayRef<Expr *> Args;
8024 Sema &S, ArrayRef<Expr *> Args,
8934 ArrayRef<Expr *> Args,
9130 ArrayRef<Expr *> Args,
9869 void Sema::NoteAllOverloadCandidates(Expr *OverloadedExpr, QualType DestType,
9938 Expr *FromExpr = Conv.Bad.FromExpr;
9944 Expr *E = FromExpr->IgnoreParens();
10957 ArrayRef<Expr *> Args,
11087 Sema &S, OverloadCandidateDisplayKind OCD, ArrayRef<Expr *> Args,
11098 void OverloadCandidateSet::NoteCandidates(Sema &S, ArrayRef<Expr *> Args,
11291 Expr* SourceExpr;
11311 AddressOfFunctionResolver(Sema &S, Expr *SourceExpr,
11701 Sema::ResolveAddressOfOverloadedFunction(Expr *AddressOfExpr,
11747 Sema::resolveAddressOfOnlyViableOverloadCandidate(Expr *E,
11785 Expr *E = SrcExpr.get();
11799 Expr *Fixed = FixOverloadedFunctionReference(E, DAP, Found);
11980 ArrayRef<Expr *> Args,
12018 ArrayRef<Expr *> Args,
12095 ArrayRef<Expr *> Args,
12197 ArrayRef<Expr *> Args) {
12226 BuildRecoveryCallExpr(Sema &SemaRef, Scope *S, Expr *Fn,
12229 MutableArrayRef<Expr *> Args,
12307 bool Sema::buildOverloadedCallSet(Scope *S, Expr *Fn,
12374 static ExprResult FinishOverloadedCallExpr(Sema &SemaRef, Scope *S, Expr *Fn,
12379 Expr *ExecConfig,
12414 for (const Expr *Arg : Args) {
12481 ExprResult Sema::BuildOverloadedCallExpr(Scope *S, Expr *Fn,
12486 Expr *ExecConfig,
12534 Expr *Input, bool PerformADL) {
12544 Expr *Args[2] = { Input, nullptr };
12557 ArrayRef<Expr *> ArgsArray(Args, NumArgs);
12602 Expr *Base = nullptr;
12638 ExprValueKind VK = Expr::getValueKindForType(ResultTy);
12724 const UnresolvedSetImpl &Fns, Expr *LHS,
12725 Expr *RHS, bool PerformADL,
12727 Expr *Args[2] = { LHS, RHS };
12861 Expr *Base = nullptr;
12925 Base = Args[0] = Arg0.getAs<Expr>();
12926 Args[1] = RHS = Arg1.getAs<Expr>();
12943 Args[0] = LHS = Arg0.getAs<Expr>();
12944 Args[1] = RHS = Arg1.getAs<Expr>();
12956 ExprValueKind VK = Expr::getValueKindForType(ResultTy);
12967 ArrayRef<const Expr *> ArgsArray(Args, 2);
12968 const Expr *ImplicitThis = nullptr;
12997 Expr *ZeroLiteral =
13130 Expr *Base, Expr *Idx) {
13130 Expr *Base, Expr *Idx) {
13131 Expr *Args[2] = { Base, Idx };
13207 Args[1] = InputInit.getAs<Expr>();
13223 ExprValueKind VK = Expr::getValueKindForType(ResultTy);
13304 Sema::BuildCallToMemberFunction(Scope *S, Expr *MemExprE,
13313 Expr *NakedMemExpr = MemExprE->IgnoreParens();
13325 ExprValueKind valueKind = Expr::getValueKindForType(proto->getReturnType());
13387 Expr::Classification ObjectClassification
13388 = UnresExpr->isArrow()? Expr::Classification::makeSimpleLValue()
13499 ExprValueKind VK = Expr::getValueKindForType(ResultType);
13586 Sema::BuildCallToObjectOfClassType(Scope *S, Expr *Obj,
13786 SmallVector<Expr *, 8> MethodArgs(NumArgsSlots);
13802 Expr *Arg;
13815 Arg = InputInit.getAs<Expr>();
13824 Arg = DefArg.getAs<Expr>();
13848 ExprValueKind VK = Expr::getValueKindForType(ResultTy);
13868 Sema::BuildOverloadedArrowExpr(Scope *S, Expr *Base, SourceLocation OpLoc,
13968 ExprValueKind VK = Expr::getValueKindForType(ResultTy);
13987 ArrayRef<Expr*> Args,
14033 Expr *ConvArgs[2];
14044 ExprValueKind VK = Expr::getValueKindForType(ResultTy);
14073 Expr *Range, ExprResult *CallExpr) {
14134 Expr *Sema::FixOverloadedFunctionReference(Expr *E, DeclAccessPair Found,
14134 Expr *Sema::FixOverloadedFunctionReference(Expr *E, DeclAccessPair Found,
14137 Expr *SubExpr = FixOverloadedFunctionReference(PE->getSubExpr(),
14146 Expr *SubExpr = FixOverloadedFunctionReference(ICE->getSubExpr(),
14163 Expr *SubExpr =
14170 ArrayRef<Expr *> A = GSE->getAssocExprs();
14171 SmallVector<Expr *, 4> AssocExprs(A.begin(), A.end());
14197 Expr *SubExpr = FixOverloadedFunctionReference(UnOp->getSubExpr(),
14223 Expr *SubExpr = FixOverloadedFunctionReference(UnOp->getSubExpr(),
14265 Expr *Base;
tools/clang/lib/Sema/SemaPseudoObject.cpp 49 typedef llvm::function_ref<Expr *(Expr *, unsigned)> SpecificRebuilderRefTy;
49 typedef llvm::function_ref<Expr *(Expr *, unsigned)> SpecificRebuilderRefTy;
55 Expr *rebuildObjCPropertyRefExpr(ObjCPropertyRefExpr *refExpr) {
73 Expr *rebuildObjCSubscriptRefExpr(ObjCSubscriptRefExpr *refExpr) {
84 Expr *rebuildMSPropertyRefExpr(MSPropertyRefExpr *refExpr) {
93 Expr *rebuildMSPropertySubscriptExpr(MSPropertySubscriptExpr *refExpr) {
97 auto *NewBase = rebuild(refExpr->getBase());
106 Expr *rebuild(Expr *e) {
106 Expr *rebuild(Expr *e) {
143 SmallVector<Expr *, 8> assocExprs;
150 Expr *assocExpr = assoc.getAssociationExpr();
166 Expr *LHS = ce->getLHS(), *RHS = ce->getRHS();
167 Expr *&rebuiltExpr = ce->isConditionTrue() ? LHS : RHS;
192 SmallVector<Expr *, 4> Semantics;
201 void addSemanticExpr(Expr *semantic) {
206 void addResultSemanticExpr(Expr *resultExpr) {
215 ExprResult buildRValueOperation(Expr *op);
219 Expr *LHS, Expr *RHS);
219 Expr *LHS, Expr *RHS);
222 Expr *op);
224 virtual ExprResult complete(Expr *syntacticForm);
226 OpaqueValueExpr *capture(Expr *op);
227 OpaqueValueExpr *captureValueAsResult(Expr *op);
238 static bool CanCaptureValue(Expr *exp) {
250 virtual Expr *rebuildAndCaptureObject(Expr *) = 0;
250 virtual Expr *rebuildAndCaptureObject(Expr *) = 0;
252 virtual ExprResult buildSet(Expr *, SourceLocation,
288 ExprResult buildRValueOperation(Expr *op);
292 Expr *LHS, Expr *RHS);
292 Expr *LHS, Expr *RHS);
295 Expr *op);
297 bool tryBuildGetOfReference(Expr *op, ExprResult &result);
302 Expr *rebuildAndCaptureObject(Expr *syntacticBase) override;
302 Expr *rebuildAndCaptureObject(Expr *syntacticBase) override;
304 ExprResult buildSet(Expr *op, SourceLocation, bool) override;
305 ExprResult complete(Expr *SyntacticForm) override;
327 ExprResult buildRValueOperation(Expr *op);
331 Expr *LHS, Expr *RHS);
331 Expr *LHS, Expr *RHS);
332 Expr *rebuildAndCaptureObject(Expr *syntacticBase) override;
332 Expr *rebuildAndCaptureObject(Expr *syntacticBase) override;
338 ExprResult buildSet(Expr *op, SourceLocation, bool) override;
344 SmallVector<Expr *, 4> CallArgs;
358 Expr *rebuildAndCaptureObject(Expr *) override;
358 Expr *rebuildAndCaptureObject(Expr *) override;
360 ExprResult buildSet(Expr *op, SourceLocation, bool) override;
366 OpaqueValueExpr *PseudoOpBuilder::capture(Expr *e) {
386 OpaqueValueExpr *PseudoOpBuilder::captureValueAsResult(Expr *e) {
412 ExprResult PseudoOpBuilder::complete(Expr *syntactic) {
418 ExprResult PseudoOpBuilder::buildRValueOperation(Expr *op) {
419 Expr *syntacticBase = rebuildAndCaptureObject(op);
433 Expr *LHS, Expr *RHS) {
433 Expr *LHS, Expr *RHS) {
436 Expr *syntacticLHS = rebuildAndCaptureObject(LHS);
445 Expr *semanticRHS = capturedRHS;
451 Expr *syntactic;
498 Expr *op) {
501 Expr *syntacticOp = rebuildAndCaptureObject(op);
518 Expr *one = IntegerLiteral::Create(S.Context, oneV, S.Context.IntTy,
708 Expr *ObjCPropertyOpBuilder::rebuildAndCaptureObject(Expr *syntacticBase) {
708 Expr *ObjCPropertyOpBuilder::rebuildAndCaptureObject(Expr *syntacticBase) {
761 ExprResult ObjCPropertyOpBuilder::buildSet(Expr *op, SourceLocation opcLoc,
798 Expr *args[] = { op };
819 Expr *arg = msgExpr->getArg(0);
828 ExprResult ObjCPropertyOpBuilder::buildRValueOperation(Expr *op) {
870 bool ObjCPropertyOpBuilder::tryBuildGetOfReference(Expr *op,
895 Expr *LHS, Expr *RHS) {
895 Expr *LHS, Expr *RHS) {
941 Expr *op) {
975 ExprResult ObjCPropertyOpBuilder::complete(Expr *SyntacticForm) {
992 ExprResult ObjCSubscriptOpBuilder::buildRValueOperation(Expr *op) {
1003 Expr *LHS, Expr *RHS) {
1003 Expr *LHS, Expr *RHS) {
1027 Expr *ObjCSubscriptOpBuilder::rebuildAndCaptureObject(Expr *syntacticBase) {
1027 Expr *ObjCSubscriptOpBuilder::rebuildAndCaptureObject(Expr *syntacticBase) {
1053 Sema::CheckSubscriptingKind(Expr *FromE) {
1070 const Expr *IndexExpr = FromE->IgnoreParenImpCasts();
1127 Expr *Key) {
1149 Expr *BaseExpr = RefExpr->getBaseExpr();
1253 Expr *BaseExpr = RefExpr->getBaseExpr();
1391 Expr *Index = InstanceKey;
1394 Expr *args[] = { Index };
1410 ExprResult ObjCSubscriptOpBuilder::buildSet(Expr *op, SourceLocation opcLoc,
1417 Expr *Index = InstanceKey;
1420 Expr *args[] = { op, Index };
1432 Expr *arg = msgExpr->getArg(0);
1447 Expr *Base = E->getBase()->IgnoreParens();
1455 Expr *MSPropertyOpBuilder::rebuildAndCaptureObject(Expr *syntacticBase) {
1455 Expr *MSPropertyOpBuilder::rebuildAndCaptureObject(Expr *syntacticBase) {
1499 ExprResult MSPropertyOpBuilder::buildSet(Expr *op, SourceLocation sl,
1523 SmallVector<Expr*, 4> ArgExprs;
1535 ExprResult Sema::checkPseudoObjectRValue(Expr *E) {
1536 Expr *opaqueRef = E->IgnoreParens();
1561 UnaryOperatorKind opcode, Expr *op) {
1568 Expr *opaqueRef = op->IgnoreParens();
1591 Expr *LHS, Expr *RHS) {
1591 Expr *LHS, Expr *RHS) {
1606 Expr *opaqueRef = LHS->IgnoreParens();
1631 static Expr *stripOpaqueValuesFromPseudoObjectRef(Sema &S, Expr *E) {
1631 static Expr *stripOpaqueValuesFromPseudoObjectRef(Sema &S, Expr *E) {
1645 Expr *Sema::recreateSyntacticForm(PseudoObjectExpr *E) {
1646 Expr *syntax = E->getSyntacticForm();
1648 Expr *op = stripOpaqueValuesFromPseudoObjectRef(*this, uop->getSubExpr());
1654 Expr *lhs = stripOpaqueValuesFromPseudoObjectRef(*this, cop->getLHS());
1655 Expr *rhs = cast<OpaqueValueExpr>(cop->getRHS())->getSourceExpr();
1665 Expr *lhs = stripOpaqueValuesFromPseudoObjectRef(*this, bop->getLHS());
1666 Expr *rhs = cast<OpaqueValueExpr>(bop->getRHS())->getSourceExpr();
tools/clang/lib/Sema/SemaStmt.cpp 128 static bool DiagnoseUnusedComparison(Sema &S, const Expr *E) {
222 const Expr *E = dyn_cast_or_null<Expr>(S);
222 const Expr *E = dyn_cast_or_null<Expr>(S);
241 const Expr *WarnExpr;
336 const Expr *Source = POE->getSyntacticForm();
343 const Expr *E = FC->getSubExpr();
437 Expr *CondExpr =
575 Expr *CondExpr = Cond.get().second;
652 static QualType GetTypeBeforeIntegralPromotion(const Expr *&E) {
662 ExprResult Sema::CheckSwitchCondition(SourceLocation SwitchLoc, Expr *Cond) {
664 Expr *Cond;
667 SwitchConvertDiagnoser(Expr *Cond)
728 Expr *CondExpr = Cond.get().second;
790 const Expr *CaseExpr,
820 static void checkEnumTypesInSwitchStmt(Sema &S, const Expr *Cond,
821 const Expr *Case) {
859 Expr *CondExpr = SS->getCond();
871 const Expr *CondExprBeforePromotion = CondExpr;
924 Expr *Lo = CS->getLHS();
933 const Expr *LoBeforePromotion = Lo;
967 Expr::EvalResult Result;
969 Expr::SE_AllowSideEffects);
991 Expr *PrevCase = CaseVals[i-1].second->getLHS()->IgnoreParenCasts();
992 Expr *CurrCase = CaseVals[i].second->getLHS()->IgnoreParenCasts();
1034 Expr *Hi = CR->getRHS();
1036 const Expr *HiBeforePromotion = Hi;
1152 Expr *CaseExpr = CI->second->getLHS();
1163 Expr *CaseExpr = RI->second->getLHS();
1261 Expr *SrcExpr) {
1338 Expr *Cond, SourceLocation CondRParen) {
1484 void CheckLValueToRValueCast(Expr *E) {
1517 for (auto *S : POE->semantics()) {
1530 void CheckForLoopConditionalStatement(Sema &S, Expr *Second,
1531 Expr *Third, Stmt *Body) {
1709 void CheckForRedundantIteration(Sema &S, Expr *Third, Stmt *Body) {
1745 void Sema::CheckBreakContinueBinding(Expr *E) {
1800 Expr *Third = third.release().getAs<Expr>();
1800 Expr *Third = third.release().getAs<Expr>();
1813 StmtResult Sema::ActOnForEachLValueExpr(Expr *E) {
1827 Sema::CheckObjCForCollectionOperand(SourceLocation forLoc, Expr *collection) {
1903 Stmt *First, Expr *collection,
1933 Expr *DeducedInit = &OpaqueId;
1953 Expr *FirstE = cast<Expr>(First);
1953 Expr *FirstE = cast<Expr>(First);
1985 static bool FinishForRangeVarDecl(Sema &SemaRef, VarDecl *Decl, Expr *Init,
2034 void NoteForRangeBeginEndFunction(Sema &SemaRef, Expr *E,
2070 static bool ObjCEnumerationCollection(Expr *Collection) {
2096 Expr *Range, SourceLocation RParenLoc,
2169 BuildNonArrayForRange(Sema &SemaRef, Expr *BeginRange, Expr *EndRange,
2169 BuildNonArrayForRange(Sema &SemaRef, Expr *BeginRange, Expr *EndRange,
2309 Expr *Range,
2359 Stmt *Begin, Stmt *End, Expr *Cond,
2360 Expr *Inc, Stmt *LoopVarDecl,
2418 Expr *Range = RangeVar->getInit();
2567 Expr *Range = BEFFailure ? EndRangeRef.get() : BeginRangeRef.get();
2710 const Expr *InitExpr = VD->getInit();
2727 const Expr *E = MTE->GetTemporaryExpr()->IgnoreImpCasts();
2783 const Expr *InitExpr = VD->getInit();
2842 const Expr *InitExpr = VD->getInit();
2886 Expr *E) {
2965 VarDecl *Sema::getCopyElisionCandidate(QualType ReturnType, Expr *E,
3046 Expr *&Value,
3052 Expr *InitExpr = &AsRvalue;
3124 Expr *Value,
3196 Expr *FakeValue = Value;
3238 Sema::ActOnCapScopeReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp) {
3445 Expr *&RetExpr,
3554 Sema::ActOnReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp,
3578 StmtResult Sema::BuildReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp) {
3777 RetValExp = Res.getAs<Expr>();
3791 RetValExp = Res.getAs<Expr>();
3847 StmtResult Sema::BuildObjCAtThrowStmt(SourceLocation AtLoc, Expr *Throw) {
3873 Sema::ActOnObjCAtThrowStmt(SourceLocation AtLoc, Expr *Throw,
3891 Sema::ActOnObjCAtSynchronizedOperand(SourceLocation atLoc, Expr *operand) {
3929 Sema::ActOnObjCAtSynchronizedStmt(SourceLocation AtLoc, Expr *SyncExpr,
4189 Expr *FilterExpr,
4279 SmallVectorImpl<Expr *> &CaptureInits) {
4431 SmallVector<Expr *, 4> CaptureInits;
tools/clang/lib/Sema/SemaStmtAsm.cpp 30 static void removeLValueToRValueCast(Expr *E) {
31 Expr *Parent = E;
32 Expr *ExprUnderCast = nullptr;
33 SmallVector<Expr *, 8> ParentsToUpdate;
42 Expr *Child = nullptr;
63 for (Expr *E : ParentsToUpdate)
69 static void emitAndFixInvalidAsmCastLValue(const Expr *LVal, Expr *BadArgument,
69 static void emitAndFixInvalidAsmCastLValue(const Expr *LVal, Expr *BadArgument,
88 static bool CheckAsmLValue(Expr *E, Sema &S) {
98 const Expr *E2 = E->IgnoreParenNoopCasts(S.Context);
127 static bool CheckNakedParmReference(Expr *E, Sema &S) {
134 SmallVector<Expr*, 4> WorkList;
137 Expr *E = WorkList.pop_back_val();
151 if (Expr *E = dyn_cast_or_null<Expr>(Child))
151 if (Expr *E = dyn_cast_or_null<Expr>(Child))
160 static bool checkExprMemoryConstraintCompat(Sema &S, Expr *E,
191 static StringRef extractRegisterName(const Expr *Expression,
244 Expr *asmString, MultiExprArg clobbers,
283 Expr *OutputExpr = Exprs[i];
300 Expr::isModifiableLvalueResult IsLV =
303 case Expr::MLV_Valid:
306 case Expr::MLV_ArrayType:
309 case Expr::MLV_LValueCast: {
310 const Expr *LVal = OutputExpr->IgnoreParenNoopCasts(Context);
315 case Expr::MLV_IncompleteType:
316 case Expr::MLV_IncompleteVoidType:
365 Expr *InputExpr = Exprs[i];
385 Expr::EvalResult EVResult;
556 Expr *OutputExpr = Exprs[TiedTo];
557 Expr *InputExpr = Exprs[InputOpNo];
668 typedef std::pair<StringRef , Expr *> NamedOperand;
698 void Sema::FillInlineAsmIdentifierInfo(Expr *Res,
701 Expr::EvalResult Eval;
835 Sema::LookupInlineAsmVarDeclField(Expr *E, StringRef Member,
881 ArrayRef<Expr*> Exprs,
tools/clang/lib/Sema/SemaStmtAttr.cpp 81 Expr *ValueExpr = A.getArgAsExpr(3);
298 Expr *E = A.getArgAsExpr(0);
tools/clang/lib/Sema/SemaTemplate.cpp 879 Expr *E = static_cast<Expr *>(Arg.getAsExpr());
1117 Expr *Default) {
1335 Expr *RequiresClause) {
2495 if (auto *E = dyn_cast_or_null<Expr>(S))
2495 if (auto *E = dyn_cast_or_null<Expr>(S))
3072 static void collectConjunctionTerms(Expr *Clause,
3073 SmallVectorImpl<Expr *> &Terms) {
3089 static Expr *lookThroughRangesV3Condition(Preprocessor &PP, Expr *Cond) {
3089 static Expr *lookThroughRangesV3Condition(Preprocessor &PP, Expr *Cond) {
3097 Expr *LHS = BinOp->getLHS();
3152 std::pair<Expr *, std::string>
3153 Sema::findFailedBooleanCondition(Expr *Cond) {
3157 SmallVector<Expr *, 4> Terms;
3161 Expr *FailedCond = nullptr;
3162 for (Expr *Term : Terms) {
3163 Expr *TermAsWritten = Term->IgnoreParenImpCasts();
3273 Expr *FailedCond;
4809 Expr *ArgE = Arg.getAs<Expr>();
4809 Expr *ArgE = Arg.getAs<Expr>();
5386 Expr *Ex = E.getAs<Expr>();
5386 Expr *Ex = E.getAs<Expr>();
5765 QualType ParamType, Expr *Arg,
5788 Expr::EvalResult EvalResult;
5841 if (Arg->isNullPointerConstant(S.Context, Expr::NPC_NeverValueDependent)) {
5860 Sema &S, NonTypeTemplateParmDecl *Param, QualType ParamType, Expr *ArgIn,
5861 Expr *Arg, QualType ArgType) {
5920 Expr *ArgIn,
5923 Expr *Arg = ArgIn;
6206 Expr *&ResultArg,
6210 Expr *Arg = ResultArg;
6361 Expr *DeductionArg = Arg;
6507 auto *E = Base.dyn_cast<const Expr *>();
7081 Expr *E;
7345 const Expr *NewRC = New->getRequiresClause();
7346 const Expr *OldRC = Old->getRequiresClause();
7529 static SourceRange findTemplateParameterInType(unsigned Depth, Expr *E) {
7567 Expr *ArgExpr = Args[I].getAsExpr();
7740 if (Expr *DefArg = NTTP->getDefaultArgument()) {
8051 Expr *ConstraintExpr) {
9919 SourceRange &CondRange, Expr *&Cond) {
10004 Expr *Cond = nullptr;
10009 Expr *FailedCond;
tools/clang/lib/Sema/SemaTemplateDeduction.cpp 174 getDeducedParameterFromExpr(TemplateDeductionInfo &Info, Expr *E) {
440 Expr *Value =
456 NonTypeTemplateParmDecl *NTTP, Expr *Value, TemplateDeductionInfo &Info,
1700 Expr *NoexceptExpr = FunctionProtoParam->getNoexceptExpr();
1721 if (Expr *ArgNoexceptExpr = FunctionProtoArg->getNoexceptExpr())
2456 Expr *E = BuildExpressionFromDeclTemplateArgument(Arg, NTTPType, Loc)
2457 .getAs<Expr>();
2464 Expr *E = BuildExpressionFromDeclTemplateArgument(Arg, NTTPType, Loc)
2465 .getAs<Expr>();
2471 Expr *E =
2472 BuildExpressionFromIntegralTemplateArgument(Arg, Loc).getAs<Expr>();
3478 Expr *Arg, QualType ParamType,
3584 QualType &ParamType, QualType &ArgType, Expr *Arg, unsigned &TDF) {
3678 QualType ParamType, Expr *Arg, TemplateDeductionInfo &Info,
3714 for (Expr *E : ILE->inits())
3720 for (Expr *E : ILE->inits()) {
3754 QualType ParamType, Expr *Arg, TemplateDeductionInfo &Info,
3810 TemplateArgumentListInfo *ExplicitTemplateArgs, ArrayRef<Expr *> Args,
4373 Sema::DeduceAutoType(TypeSourceInfo *Type, Expr *&Init, QualType &Result,
4419 Sema::DeduceAutoType(TypeLoc Type, Expr *&Init, QualType &Result,
4523 for (Expr *E : InitList->inits())
4529 Expr *Init = InitList->getInit(i);
4616 void Sema::DiagnoseAutoDeductionFailure(VarDecl *VDecl, Expr *Init) {
5259 const Expr *E,
5465 if (auto *E = Proto->getNoexceptExpr())
tools/clang/lib/Sema/SemaTemplateInstantiate.cpp 1304 Expr *TransformedExpr = getDerived().TransformExpr(LH->getValue()).get();
1329 Expr *argExpr = arg.getAsExpr();
1377 Expr *resultExpr = result.get();
1864 Expr *Arg = OldParm->getUninstantiatedDefaultArg();
1869 } else if (Expr *Arg = OldParm->getDefaultArg()) {
2405 Expr *OldInit = Pattern->getInClassInitializer();
2443 Expr *Init = NewInit.get();
2923 bool Sema::SubstExprs(ArrayRef<Expr *> Exprs, bool IsCall,
2925 SmallVectorImpl<Expr *> &Outputs) {
tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp 89 S.AddAlignedAttr(New, *Aligned, Result.getAs<Expr>(), IsPackExpansion);
144 Expr *E, *OE = nullptr;
148 E = Result.getAs<Expr>();
154 OE = Result.getAs<Expr>();
168 S.AddAlignValueAttr(New, *Aligned, Result.getAs<Expr>());
174 Expr *Param = IntegerLiteral::Create(
181 static Expr *instantiateDependentFunctionAttrCondition(
183 const Attr *A, Expr *OldCond, const Decl *Tmpl, FunctionDecl *New) {
184 Expr *Cond = nullptr;
192 Cond = Result.getAs<Expr>();
203 !Expr::isPotentialConstantExprUnevaluated(Cond, New, Diags)) {
215 Expr *Cond = instantiateDependentFunctionAttrCondition(
226 Expr *Cond = instantiateDependentFunctionAttrCondition(
247 Expr *MaxThreads = Result.getAs<Expr>();
247 Expr *MaxThreads = Result.getAs<Expr>();
249 Expr *MinBlocks = nullptr;
254 MinBlocks = Result.getAs<Expr>();
277 SmallVector<Expr *, 4> Uniforms, Aligneds, Alignments, Linears, Steps;
307 if (auto *E = Attr.getSimdlen())
311 for(auto *E : Attr.uniforms()) {
320 for (auto *E : Attr.aligneds()) {
333 for (auto *E : Attr.linears()) {
388 if (Expr *E = Attr.getVariantFuncRef())
392 if (Expr *E = Attr.getScore())
396 Optional<std::pair<FunctionDecl *, Expr *>> DeclVarData =
422 Expr *MinExpr = Result.getAs<Expr>();
422 Expr *MinExpr = Result.getAs<Expr>();
427 Expr *MaxExpr = Result.getAs<Expr>();
427 Expr *MaxExpr = Result.getAs<Expr>();
438 Expr *OldCond = ES.getExpr();
439 Expr *Cond = nullptr;
465 Expr *MinExpr = Result.getAs<Expr>();
465 Expr *MinExpr = Result.getAs<Expr>();
467 Expr *MaxExpr = nullptr;
472 MaxExpr = Result.getAs<Expr>();
962 Expr *BitWidth = D->getBitWidth();
976 BitWidth = InstantiatedBitWidth.getAs<Expr>();
1141 Expr *AssertExpr = D->getAssertExpr();
1252 if (Expr *UninstValue = EC->getInitExpr()) {
2982 SmallVector<Expr *, 5> Vars;
2983 for (auto *I : D->varlists()) {
2984 Expr *Var = SemaRef.SubstExpr(I, TemplateArgs).get();
2999 SmallVector<Expr *, 5> Vars;
3000 for (auto *I : D->varlists()) {
3001 Expr *Var = SemaRef.SubstExpr(I, TemplateArgs).get();
3063 if (Expr *Combiner = D->getCombiner()) {
3066 if (Expr *Init = D->getInitializer()) {
3075 Expr *SubstCombiner = nullptr;
3076 Expr *SubstInitializer = nullptr;
3183 SmallVector<Expr *, 4> NewVars;
3184 for (Expr *OE : OldC->varlists()) {
3185 Expr *NE = SemaRef.SubstExpr(OE, TemplateArgs).get();
3524 Expr *InstRequiresClause = nullptr;
3525 if (Expr *E = L->getRequiresClause()) {
4641 Expr *InitExpr = Init.get();
tools/clang/lib/Sema/SemaTemplateVariadic.cpp 134 Expr *E = dyn_cast_or_null<Expr>(S);
134 Expr *E = dyn_cast_or_null<Expr>(S);
264 Expr *Init) {
397 bool Sema::DiagnoseUnexpandedParameterPack(Expr *E,
620 ExprResult Sema::ActOnPackExpansion(Expr *Pattern, SourceLocation EllipsisLoc) {
624 ExprResult Sema::CheckPackExpansion(Expr *Pattern, SourceLocation EllipsisLoc,
1059 Expr *Pattern = Expansion->getPattern();
1141 static void CheckFoldOperand(Sema &S, Expr *E) {
1156 ExprResult Sema::ActOnCXXFoldExpr(SourceLocation LParenLoc, Expr *LHS,
1158 SourceLocation EllipsisLoc, Expr *RHS,
1189 Expr *Pack = LHS ? LHS : RHS;
1202 ExprResult Sema::BuildCXXFoldExpr(SourceLocation LParenLoc, Expr *LHS,
1204 SourceLocation EllipsisLoc, Expr *RHS,
tools/clang/lib/Sema/SemaType.cpp 1564 Expr *E = DS.getRepAsExpr();
1575 Expr *E = DS.getRepAsExpr();
2107 static bool isArraySizeVLA(Sema &S, Expr *ArraySize, llvm::APSInt &SizeVal) {
2143 Expr *ArraySize, unsigned Quals,
2349 QualType Sema::BuildVectorType(QualType CurType, Expr *SizeExpr,
2404 QualType Sema::BuildExtVectorType(QualType T, Expr *ArraySize,
4473 Expr *ArraySize = static_cast<Expr*>(ATI.NumElts);
4897 Expr *NoexceptExpr = nullptr;
5893 const Expr *AddrSpace,
5937 QualType Sema::BuildAddressSpaceAttr(QualType &T, LangAS ASIdx, Expr *AddrSpace,
5960 QualType Sema::BuildAddressSpaceAttr(QualType &T, Expr *AddrSpace,
5995 Expr *ASArgExpr;
7144 Expr *SizeExpr;
7181 Expr *sizeExpr;
7280 Expr *numEltsExpr = static_cast<Expr *>(Attr.getArgAsExpr(0));
7730 void Sema::completeExprArrayBound(Expr *E) {
7788 bool Sema::RequireCompleteExprType(Expr *E, TypeDiagnoser &Diagnoser) {
7806 bool Sema::RequireCompleteExprType(Expr *E, unsigned DiagID) {
8297 QualType Sema::BuildTypeofExprType(Expr *E, SourceLocation Loc) {
8314 static QualType getDecltypeForExpr(Sema &S, Expr *E) {
8381 QualType Sema::BuildDecltypeType(Expr *E, SourceLocation Loc,
tools/clang/lib/Sema/TreeTransform.h 217 bool DropCallArgument(Expr *E) {
417 bool TransformExprs(Expr *const *Inputs, unsigned NumInputs, bool IsCall,
418 SmallVectorImpl<Expr *> &Outputs,
441 Expr *Expr,
786 Expr *SizeExpr,
798 Expr *SizeExpr,
819 Expr *SizeExpr,
830 Expr *SizeExpr,
847 QualType RebuildDependentVectorType(QualType ElementType, Expr *SizeExpr,
865 Expr *SizeExpr,
877 Expr *AddrSpaceExpr,
920 QualType RebuildTypeOfExprType(Expr *Underlying, SourceLocation Loc);
936 QualType RebuildDecltypeType(Expr *Underlying, SourceLocation Loc);
1234 Expr *LHS,
1236 Expr *RHS,
1325 Expr *Cond, SourceLocation RParenLoc) {
1357 Expr *Target) {
1365 StmtResult RebuildReturnStmt(SourceLocation ReturnLoc, Expr *Result) {
1387 Expr *AsmString, MultiExprArg Clobbers,
1405 ArrayRef<Expr*> Exprs,
1416 StmtResult RebuildCoreturnStmt(SourceLocation CoreturnLoc, Expr *Result,
1502 Expr *Operand) {
1525 Expr *Condition, SourceLocation StartLoc,
1539 OMPClause *RebuildOMPFinalClause(Expr *Condition, SourceLocation StartLoc,
1550 OMPClause *RebuildOMPNumThreadsClause(Expr *NumThreads,
1562 OMPClause *RebuildOMPSafelenClause(Expr *Len, SourceLocation StartLoc,
1572 OMPClause *RebuildOMPSimdlenClause(Expr *Len, SourceLocation StartLoc,
1582 OMPClause *RebuildOMPAllocatorClause(Expr *A, SourceLocation StartLoc,
1592 OMPClause *RebuildOMPCollapseClause(Expr *Num, SourceLocation StartLoc,
1631 OpenMPScheduleClauseKind Kind, Expr *ChunkSize, SourceLocation StartLoc,
1645 SourceLocation LParenLoc, Expr *Num) {
1653 OMPClause *RebuildOMPPrivateClause(ArrayRef<Expr *> VarList,
1665 OMPClause *RebuildOMPFirstprivateClause(ArrayRef<Expr *> VarList,
1677 OMPClause *RebuildOMPLastprivateClause(ArrayRef<Expr *> VarList,
1689 OMPClause *RebuildOMPSharedClause(ArrayRef<Expr *> VarList,
1701 OMPClause *RebuildOMPReductionClause(ArrayRef<Expr *> VarList,
1708 ArrayRef<Expr *> UnresolvedReductions) {
1719 ArrayRef<Expr *> VarList, SourceLocation StartLoc,
1723 ArrayRef<Expr *> UnresolvedReductions) {
1734 RebuildOMPInReductionClause(ArrayRef<Expr *> VarList, SourceLocation StartLoc,
1739 ArrayRef<Expr *> UnresolvedReductions) {
1749 OMPClause *RebuildOMPLinearClause(ArrayRef<Expr *> VarList, Expr *Step,
1749 OMPClause *RebuildOMPLinearClause(ArrayRef<Expr *> VarList, Expr *Step,
1765 OMPClause *RebuildOMPAlignedClause(ArrayRef<Expr *> VarList, Expr *Alignment,
1765 OMPClause *RebuildOMPAlignedClause(ArrayRef<Expr *> VarList, Expr *Alignment,
1778 OMPClause *RebuildOMPCopyinClause(ArrayRef<Expr *> VarList,
1790 OMPClause *RebuildOMPCopyprivateClause(ArrayRef<Expr *> VarList,
1802 OMPClause *RebuildOMPFlushClause(ArrayRef<Expr *> VarList,
1816 SourceLocation ColonLoc, ArrayRef<Expr *> VarList,
1827 OMPClause *RebuildOMPDeviceClause(Expr *Device, SourceLocation StartLoc,
1843 SourceLocation MapLoc, SourceLocation ColonLoc, ArrayRef<Expr *> VarList,
1844 const OMPVarListLocTy &Locs, ArrayRef<Expr *> UnresolvedMappers) {
1855 OMPClause *RebuildOMPAllocateClause(Expr *Allocate, ArrayRef<Expr *> VarList,
1855 OMPClause *RebuildOMPAllocateClause(Expr *Allocate, ArrayRef<Expr *> VarList,
1868 OMPClause *RebuildOMPNumTeamsClause(Expr *NumTeams, SourceLocation StartLoc,
1879 OMPClause *RebuildOMPThreadLimitClause(Expr *ThreadLimit,
1891 OMPClause *RebuildOMPPriorityClause(Expr *Priority, SourceLocation StartLoc,
1902 OMPClause *RebuildOMPGrainsizeClause(Expr *Grainsize, SourceLocation StartLoc,
1913 OMPClause *RebuildOMPNumTasksClause(Expr *NumTasks, SourceLocation StartLoc,
1924 OMPClause *RebuildOMPHintClause(Expr *Hint, SourceLocation StartLoc,
1936 Expr *ChunkSize, SourceLocation StartLoc,
1947 OMPClause *RebuildOMPToClause(ArrayRef<Expr *> VarList,
1951 ArrayRef<Expr *> UnresolvedMappers) {
1960 OMPClause *RebuildOMPFromClause(ArrayRef<Expr *> VarList,
1964 ArrayRef<Expr *> UnresolvedMappers) {
1973 OMPClause *RebuildOMPUseDevicePtrClause(ArrayRef<Expr *> VarList,
1982 OMPClause *RebuildOMPIsDevicePtrClause(ArrayRef<Expr *> VarList,
2001 Expr *Object, Stmt *Body) {
2020 Expr *Collection,
2076 Stmt *Begin, Stmt *End, Expr *Cond,
2077 Expr *Inc, Stmt *LoopVar,
2087 Expr *RangeExpr = RangeVar->getInit();
2135 StmtResult RebuildSEHExceptStmt(SourceLocation Loc, Expr *FilterExpr,
2901 SmallVector<Expr*, 8> ConvertedArgs;
3234 Expr *Callee = new (SemaRef.Context)
3244 Expr::getValueKindForType(Builtin->getReturnType()), RParenLoc);
3397 ExprResult E = getDerived().TransformExpr(cast<Expr>(S));
3504 SmallVector<Expr*, 8> NewArgs;
3529 bool TreeTransform<Derived>::TransformExprs(Expr *const *Inputs,
3532 SmallVectorImpl<Expr *> &Outputs,
3544 Expr *Pattern = Expansion->getPattern();
3643 SourceLocation Loc, VarDecl *Var, Expr *Expr, Sema::ConditionKind Kind) {
4040 Expr *InputExpr = Input.getSourceExpression();
4761 Expr *OldSize = TL.getSizeExpr();
4764 Expr *NewSize = nullptr;
4768 NewSize = getDerived().TransformExpr(OldSize).template getAs<Expr>();
4847 Expr *Size = SizeResult.get();
4886 Expr *origSize = TL.getSizeExpr();
4895 Expr *size = sizeResult.get();
7072 SmallVector<Expr*, 8> Constraints;
7073 SmallVector<Expr*, 8> Exprs;
7077 SmallVector<Expr*, 8> Clobbers;
7089 Expr *OutputExpr = S->getOutputExpr(I);
7107 Expr *InputExpr = S->getInputExpr(I);
7152 ArrayRef<Expr*> SrcExprs = S->getAllExprs();
7153 SmallVector<Expr*, 8> TransformedExprs;
7223 Expr *ReturnObject = S->getReturnValueInit();
8590 if (auto *Num = C->getNumForLoops()) {
8709 llvm::SmallVector<Expr *, 16> Vars;
8711 for (auto *VE : C->varlists()) {
8712 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
8724 llvm::SmallVector<Expr *, 16> Vars;
8726 for (auto *VE : C->varlists()) {
8727 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
8739 llvm::SmallVector<Expr *, 16> Vars;
8741 for (auto *VE : C->varlists()) {
8742 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
8754 llvm::SmallVector<Expr *, 16> Vars;
8756 for (auto *VE : C->varlists()) {
8757 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
8769 llvm::SmallVector<Expr *, 16> Vars;
8771 for (auto *VE : C->varlists()) {
8772 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
8788 llvm::SmallVector<Expr *, 16> UnresolvedReductions;
8789 for (auto *E : C->reduction_ops()) {
8816 llvm::SmallVector<Expr *, 16> Vars;
8818 for (auto *VE : C->varlists()) {
8819 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
8835 llvm::SmallVector<Expr *, 16> UnresolvedReductions;
8836 for (auto *E : C->reduction_ops()) {
8861 llvm::SmallVector<Expr *, 16> Vars;
8863 for (auto *VE : C->varlists()) {
8864 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
8880 llvm::SmallVector<Expr *, 16> UnresolvedReductions;
8881 for (auto *E : C->reduction_ops()) {
8906 llvm::SmallVector<Expr *, 16> Vars;
8908 for (auto *VE : C->varlists()) {
8909 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
8925 llvm::SmallVector<Expr *, 16> Vars;
8927 for (auto *VE : C->varlists()) {
8928 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
8944 llvm::SmallVector<Expr *, 16> Vars;
8946 for (auto *VE : C->varlists()) {
8947 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
8959 llvm::SmallVector<Expr *, 16> Vars;
8961 for (auto *VE : C->varlists()) {
8962 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
8973 llvm::SmallVector<Expr *, 16> Vars;
8975 for (auto *VE : C->varlists()) {
8976 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
8988 llvm::SmallVector<Expr *, 16> Vars;
8990 for (auto *VE : C->varlists()) {
8991 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
9014 llvm::SmallVectorImpl<Expr *> &Vars, CXXScopeSpec &MapperIdScopeSpec,
9016 llvm::SmallVectorImpl<Expr *> &UnresolvedMappers) {
9019 for (auto *VE : C->varlists()) {
9020 ExprResult EVar = TT.getDerived().TransformExpr(cast<Expr>(VE));
9042 for (auto *E : C->mapperlists()) {
9067 llvm::SmallVector<Expr *, 16> Vars;
9070 llvm::SmallVector<Expr *, 16> UnresolvedMappers;
9083 Expr *Allocator = C->getAllocator();
9090 llvm::SmallVector<Expr *, 16> Vars;
9092 for (auto *VE : C->varlists()) {
9093 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
9182 llvm::SmallVector<Expr *, 16> Vars;
9185 llvm::SmallVector<Expr *, 16> UnresolvedMappers;
9196 llvm::SmallVector<Expr *, 16> Vars;
9199 llvm::SmallVector<Expr *, 16> UnresolvedMappers;
9210 llvm::SmallVector<Expr *, 16> Vars;
9212 for (auto *VE : C->varlists()) {
9213 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
9225 llvm::SmallVector<Expr *, 16> Vars;
9227 for (auto *VE : C->varlists()) {
9228 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
9369 SmallVector<Expr *, 4> AssocExprs;
9467 Expr *FromIndex = E->getIndexExpr(ON.getArrayExprIndex());
9529 Expr *newSyntacticForm = SemaRef.recreateSyntacticForm(E);
9657 SmallVector<Expr*, 8> Args;
9804 Expr *PossibleBinOps[] = {E->getSemanticForm(),
9806 for (Expr *PossibleBinOp : PossibleBinOps) {
9975 SmallVector<Expr*, 4> Inits;
10002 SmallVector<Expr*, 4> ArrayExprs;
10146 SmallVector<Expr*, 4> Inits;
10252 SmallVector<Expr*, 8> Args;
10346 SmallVector<Expr*, 8> Args;
10623 Optional<Expr *> ArraySize;
10624 if (Optional<Expr *> OldArraySize = E->getArraySize()) {
10636 SmallVector<Expr*, 8> PlacementArgs;
10643 Expr *OldInit = E->getInitializer();
11260 SmallVector<Expr*, 8> Args;
11349 SmallVector<Expr*, 8> Args;
11409 Expr *NewExprInit = NewExprInitResult.get();
11754 SmallVector<Expr*, 8> Args;
11781 Expr *OldBase;
12154 Expr *Pattern = E->getPattern();
12309 SmallVector<Expr *, 8> Elements;
12505 SmallVector<Expr*, 8> Args;
12687 SmallVector<Expr*, 8> SubExprs;
12810 SmallVector<Expr*, 8> SubExprs;
12903 Expr *SizeExpr,
12939 Expr *SizeExpr,
12960 Expr *SizeExpr,
12972 Expr *SizeExpr,
12982 QualType PointeeType, Expr *AddrSpaceExpr, SourceLocation AttributeLoc) {
12998 QualType ElementType, Expr *SizeExpr, SourceLocation AttributeLoc,
13018 Expr *SizeExpr,
13092 QualType TreeTransform<Derived>::RebuildTypeOfExprType(Expr *E,
13103 QualType TreeTransform<Derived>::RebuildDecltypeType(Expr *E,
13194 Expr *Callee = OrigCallee->IgnoreParenCasts();
13272 Expr *Args[2] = { First, Second };
tools/clang/lib/Serialization/ASTReader.cpp 6445 Expr *SizeExpr = ReadExpr(*Loc.F);
6809 Expr *NumElts = ReadExpr(*Loc.F);
6856 Expr *SizeExpr = ReadExpr(*Loc.F);
6869 Expr *SizeExpr = ReadExpr(*Loc.F);
6881 Expr *AddrSpaceExpr = ReadExpr(*Loc.F);
9349 Expr *RequiresClause = HasRequiresClause ? ReadExpr(F) : nullptr;
9429 Expr *Init = ReadExpr(F);
10790 Expr *FirstExpr = FirstSA->getAssertExpr();
10791 Expr *SecondExpr = SecondSA->getAssertExpr();
10914 const Expr *FirstInitializer = FirstField->getInClassInitializer();
10915 const Expr *SecondInitializer = SecondField->getInClassInitializer();
11145 const Expr *FirstInit = FirstParam->getInit();
11146 const Expr *SecondInit = SecondParam->getInit();
11372 const Expr *FirstInit = FirstVD->getInit();
11373 const Expr *SecondInit = SecondVD->getInit();
11718 Expr *FirstDefaultArgument = FirstNTTPD->getDefaultArgument();
11719 Expr *SecondDefaultArgument = SecondNTTPD->getDefaultArgument();
11892 const Expr *FirstInit = FirstParam->getInit();
11893 const Expr *SecondInit = SecondParam->getInit();
12093 const Expr *FirstInit = FirstEnumConstant->getInitExpr();
12094 const Expr *SecondInit = SecondEnumConstant->getInitExpr();
12616 SmallVector<Expr *, 16> Vars;
12631 SmallVector<Expr *, 16> Vars;
12650 SmallVector<Expr *, 16> Vars;
12676 SmallVector<Expr *, 16> Vars;
12694 SmallVector<Expr *, 16> Vars;
12728 SmallVector<Expr *, 16> Vars;
12762 SmallVector<Expr *, 16> Vars;
12796 SmallVector<Expr *, 16> Vars;
12829 SmallVector<Expr *, 16> Vars;
12840 SmallVector<Expr *, 16> Exprs;
12862 SmallVector<Expr *, 16> Exprs;
12884 SmallVector<Expr *, 16> Vars;
12898 SmallVector<Expr *, 16> Vars;
12933 SmallVector<Expr *, 16> Vars;
12939 SmallVector<Expr *, 16> UDMappers;
12966 Expr *AssociatedExpr = Record.readExpr();
12979 SmallVector<Expr *, 16> Vars;
13052 SmallVector<Expr *, 16> Vars;
13058 SmallVector<Expr *, 16> UDMappers;
13085 Expr *AssociatedExpr = Record.readSubExpr();
13104 SmallVector<Expr *, 16> Vars;
13110 SmallVector<Expr *, 16> UDMappers;
13137 Expr *AssociatedExpr = Record.readSubExpr();
13152 SmallVector<Expr *, 16> Vars;
13187 Expr *AssociatedExpr = Record.readSubExpr();
13202 SmallVector<Expr *, 16> Vars;
13230 Expr *AssociatedExpr = Record.readSubExpr();
tools/clang/lib/Serialization/ASTReaderDecl.cpp 1331 if (auto *BW = Record.readExpr())
1402 Expr *CopyExpr = Record.readExpr();
1510 Expr *copyExpr = ((flags & 4) ? Record.readExpr() : nullptr);
1941 auto *ThisArg = Record.readExpr();
2571 SmallVector<Expr *, 16> Vars;
2583 SmallVector<Expr *, 16> Vars;
2611 Expr *In = Record.readExpr();
2612 Expr *Out = Record.readExpr();
2614 Expr *Combiner = Record.readExpr();
2616 Expr *Orig = Record.readExpr();
2617 Expr *Priv = Record.readExpr();
2619 Expr *Init = Record.readExpr();
2628 Expr *MapperVarRefE = Record.readExpr();
2671 Expr *readExpr() { return Reader->ReadExpr(*F); }
4315 auto *DefaultArg = Record.readExpr();
4326 auto *DefaultInit = Record.readExpr();
4429 auto *ThisArg = Record.readExpr();
4493 Expr *Allocator = Record.readExpr();
tools/clang/lib/Serialization/ASTReaderStmt.cpp 437 SmallVector<Expr*, 16> Exprs;
444 Exprs.push_back(cast<Expr>(Record.readSubStmt()));
521 void ASTStmtReader::VisitExpr(Expr *E) {
940 Expr *filler = nullptr;
951 Expr *init = Record.readSubExpr();
1088 SmallVector<Expr *, 16> Exprs;
1143 Expr *subExpr = Record.readSubExpr();
1179 Expr **Elements = E->getElements();
2066 SmallVector<Expr *, 4> Sub;
2421 Expr *ASTReader::ReadExpr(ModuleFile &F) {
2422 return cast_or_null<Expr>(ReadStmt(F));
2425 Expr *ASTReader::ReadSubExpr() {
2426 return cast_or_null<Expr>(ReadSubStmt());
tools/clang/lib/Serialization/ASTWriter.cpp 6078 if (const Expr *RequiresClause = TemplateParams->getRequiresClause()) {
6433 Expr *ThisArg) {
6703 for (Expr *NumIter : C->getLoopNumIterations())
6735 for (auto *VE : C->varlists()) {
6738 for (auto *VE : C->private_copies()) {
6747 for (auto *VE : C->varlists()) {
6750 for (auto *VE : C->private_copies()) {
6753 for (auto *VE : C->inits()) {
6762 for (auto *VE : C->varlists())
6764 for (auto *E : C->private_copies())
6766 for (auto *E : C->source_exprs())
6768 for (auto *E : C->destination_exprs())
6770 for (auto *E : C->assignment_ops())
6777 for (auto *VE : C->varlists())
6788 for (auto *VE : C->varlists())
6790 for (auto *VE : C->privates())
6792 for (auto *E : C->lhs_exprs())
6794 for (auto *E : C->rhs_exprs())
6796 for (auto *E : C->reduction_ops())
6807 for (auto *VE : C->varlists())
6809 for (auto *VE : C->privates())
6811 for (auto *E : C->lhs_exprs())
6813 for (auto *E : C->rhs_exprs())
6815 for (auto *E : C->reduction_ops())
6826 for (auto *VE : C->varlists())
6828 for (auto *VE : C->privates())
6830 for (auto *E : C->lhs_exprs())
6832 for (auto *E : C->rhs_exprs())
6834 for (auto *E : C->reduction_ops())
6836 for (auto *E : C->taskgroup_descriptors())
6847 for (auto *VE : C->varlists()) {
6850 for (auto *VE : C->privates()) {
6853 for (auto *VE : C->inits()) {
6856 for (auto *VE : C->updates()) {
6859 for (auto *VE : C->finals()) {
6864 for (auto *VE : C->used_expressions())
6872 for (auto *VE : C->varlists())
6880 for (auto *VE : C->varlists())
6882 for (auto *E : C->source_exprs())
6884 for (auto *E : C->destination_exprs())
6886 for (auto *E : C->assignment_ops())
6893 for (auto *VE : C->varlists())
6895 for (auto *E : C->source_exprs())
6897 for (auto *E : C->destination_exprs())
6899 for (auto *E : C->assignment_ops())
6906 for (auto *VE : C->varlists())
6917 for (auto *VE : C->varlists())
6944 for (auto *E : C->varlists())
6946 for (auto *E : C->mapperlists())
6965 for (auto *VE : C->varlists())
7029 for (auto *E : C->varlists())
7031 for (auto *E : C->mapperlists())
7053 for (auto *E : C->varlists())
7055 for (auto *E : C->mapperlists())
7075 for (auto *E : C->varlists())
7077 for (auto *VE : C->private_copies())
7079 for (auto *VE : C->inits())
7099 for (auto *E : C->varlists())
tools/clang/lib/Serialization/ASTWriterDecl.cpp 1782 for (auto *I : D->varlists())
1791 for (auto *I : D->varlists())
tools/clang/lib/Serialization/ASTWriterStmt.cpp 421 for (auto *I : S->capture_inits())
440 void ASTStmtWriter::VisitExpr(Expr *E) {
597 for (auto *SubStmt : E->exprs())
858 bool isArrayFiller = E->ArrayFillerOrUnionFieldInit.is<Expr*>();
869 Expr *filler = E->getArrayFiller();
tools/clang/lib/StaticAnalyzer/Checkers/AllocationState.h 21 const Expr *Origin);
tools/clang/lib/StaticAnalyzer/Checkers/BasicObjCFoundationChecks.cpp 113 void warnIfNilExpr(const Expr *E,
125 const Expr *Expr,
137 void NilArgChecker::warnIfNilExpr(const Expr *E,
209 const Expr *E,
351 void EmitError(const TypedRegion* R, const Expr *Ex,
1036 const Expr *MsgExpr = M.getOriginExpr();
1154 ProgramStateRef assumeExprIsNonNull(const Expr *NonNullExpr,
1157 void assumeExprIsNonNull(const Expr *E, CheckerContext &C) const {
1176 ObjCNonNilReturnValueChecker::assumeExprIsNonNull(const Expr *NonNullExpr,
tools/clang/lib/StaticAnalyzer/Checkers/BuiltinFunctionChecker.cpp 40 const Expr *CE = Call.getOriginExpr();
110 Expr::EvalResult EVResult;
111 if (CE->EvaluateAsInt(EVResult, C.getASTContext(), Expr::SE_NoSideEffects)) {
tools/clang/lib/StaticAnalyzer/Checkers/CStringChecker.cpp 114 const Expr *Size,
115 const Expr *Source,
116 const Expr *Dest,
170 const Expr *Ex,
175 const Expr *Ex,
181 const Expr *expr,
186 const Expr *Ex, SVal V,
188 const Expr *Size);
193 static bool memsetAux(const Expr *DstBuffer, SVal CharE,
194 const Expr *Size, CheckerContext &C,
200 const Expr *S,
205 const Expr *S,
210 const Expr *Size,
211 const Expr *FirstBuf,
212 const Expr *SecondBuf,
219 const Expr *Size,
220 const Expr *Buf,
229 const Expr *Size,
230 const Expr *First,
231 const Expr *Second) const;
255 const Expr *FirstBuf,
256 const Expr *Size);
281 const Expr *S, SVal l,
312 const Expr *S, SVal l,
372 const Expr *Size,
373 const Expr *FirstBuf,
374 const Expr *SecondBuf,
417 const Expr *warningExpr = (WarnAboutSize ? Size : FirstBuf);
437 const Expr *warningExpr = (WarnAboutSize ? Size : SecondBuf);
451 const Expr *Size,
452 const Expr *First,
453 const Expr *Second) const {
592 if (const auto *Ex = dyn_cast<Expr>(S))
592 if (const auto *Ex = dyn_cast<Expr>(S))
755 const Expr *Ex,
793 const Expr *Ex, SVal Buf,
867 ProgramStateRef &state, const Expr *expr, SVal val) const {
888 const Expr *FirstBuf,
889 const Expr *Size) {
954 const Expr *E, SVal V,
956 const Expr *Size) {
1046 bool CStringChecker::memsetAux(const Expr *DstBuffer, SVal CharVal,
1047 const Expr *Size, CheckerContext &C,
1141 const Expr *Size, const Expr *Dest,
1141 const Expr *Size, const Expr *Dest,
1142 const Expr *Source, bool Restricted,
1243 const Expr *Dest = CE->getArg(0);
1252 const Expr *Dest = CE->getArg(0);
1261 const Expr *Dest = CE->getArg(0);
1277 const Expr *Left = CE->getArg(0);
1278 const Expr *Right = CE->getArg(1);
1279 const Expr *Size = CE->getArg(2);
1365 const Expr *maxlenExpr = CE->getArg(1);
1389 const Expr *Arg = CE->getArg(0);
1413 const Expr *maxlenExpr = CE->getArg(1);
1547 const Expr *Dst = CE->getArg(0);
1555 const Expr *srcExpr = CE->getArg(1);
1587 const Expr *lenExpr = CE->getArg(2);
1911 const Expr *s1 = CE->getArg(0);
1918 const Expr *s2 = CE->getArg(1);
1977 const Expr *lenExpr = CE->getArg(2);
2034 const Expr *SearchStrPtr = CE->getArg(0);
2052 const Expr *DelimStr = CE->getArg(1);
2114 const Expr *Dst = CE->getArg(2);
2130 const Expr *Mem = CE->getArg(0);
2131 const Expr *CharE = CE->getArg(1);
2132 const Expr *Size = CE->getArg(2);
2178 const Expr *Mem = CE->getArg(0);
2179 const Expr *Size = CE->getArg(1);
2288 const Expr *Init = D->getInit();
tools/clang/lib/StaticAnalyzer/Checkers/CStringSyntaxChecker.cpp 38 bool sameDecl(const Expr *A1, const Expr *A2) {
38 bool sameDecl(const Expr *A1, const Expr *A2) {
46 bool isSizeof(const Expr *E, const Expr *WithArg) {
46 bool isSizeof(const Expr *E, const Expr *WithArg) {
54 bool isStrlen(const Expr *E, const Expr *WithArg) {
54 bool isStrlen(const Expr *E, const Expr *WithArg) {
66 bool isOne(const Expr *E) {
72 StringRef getPrintableName(const Expr *E) {
125 const Expr *DstArg = CE->getArg(0);
126 const Expr *SrcArg = CE->getArg(1);
127 const Expr *LenArg = CE->getArg(2);
133 const Expr *L = BE->getLHS();
134 const Expr *R = BE->getRHS();
156 const Expr *DstArg = CE->getArg(0);
157 const Expr *LenArg = CE->getArg(2);
220 const Expr *DstArg = CE->getArg(0);
221 const Expr *LenArg = CE->getArg(2);
245 const Expr *DstArg = CE->getArg(0);
246 const Expr *LenArg = CE->getArg(2);
tools/clang/lib/StaticAnalyzer/Checkers/CallAndMessageChecker.cpp 67 const Expr *ArgEx, int ArgumentNumber,
72 static void emitBadCall(BugType *BT, CheckerContext &C, const Expr *BadE);
85 SourceRange ArgRange, const Expr *ArgEx,
93 const Expr *BadE) {
144 CheckerContext &C, const SVal &V, SourceRange ArgRange, const Expr *ArgEx,
235 const Expr *ArgEx,
317 const Expr *Callee = CE->getCallee()->IgnoreParens();
490 if (const Expr *ReceiverE = ME->getInstanceReceiver())
532 if (const Expr *receiver = ME->getInstanceReceiver()) {
tools/clang/lib/StaticAnalyzer/Checkers/CastSizeChecker.cpp 88 const Expr *E = CE->getSubExpr();
tools/clang/lib/StaticAnalyzer/Checkers/CastToStructChecker.cpp 40 const Expr *E = CE->getSubExpr();
tools/clang/lib/StaticAnalyzer/Checkers/CastValueChecker.cpp 105 QualType CastToTy, const Expr *Object,
163 const Expr *Object;
tools/clang/lib/StaticAnalyzer/Checkers/CheckSecuritySyntaxOnly.cpp 210 getIncrementedVar(const Expr *expr, const VarDecl *x, const VarDecl *y) {
248 const Expr *condition = FS->getCond();
254 const Expr *increment = FS->getInc();
612 const Expr *suffixEx = CE->getArg((unsigned)ArgSuffix.second);
613 Expr::EvalResult EVResult;
666 const auto *Target = CE->getArg(0)->IgnoreImpCasts(),
tools/clang/lib/StaticAnalyzer/Checkers/CheckSizeofPointer.cpp 60 Expr *ArgEx = E->getArgumentExpr();
tools/clang/lib/StaticAnalyzer/Checkers/ChrootChecker.cpp 98 const Expr *ArgExpr = Call.getArgExpr(0);
tools/clang/lib/StaticAnalyzer/Checkers/DeadStoresChecker.cpp 102 static const Expr *
103 LookThroughTransitiveAssignmentsAndCommaOperators(const Expr *Ex) {
267 void CheckVarDecl(const VarDecl *VD, const Expr *Ex, const Expr *Val,
267 void CheckVarDecl(const VarDecl *VD, const Expr *Ex, const Expr *Val,
288 void CheckDeclRef(const DeclRefExpr *DR, const Expr *Val, DeadStoreKind dsk,
298 const Expr *RHS = B->getRHS()->IgnoreParenCasts();
335 const Expr *RHS =
343 if (RHS->isNullPointerConstant(Ctx, Expr::NPC_ValueDependentIsNull))
369 const Expr *Ex = U->getSubExpr()->IgnoreParenCasts();
389 if (const Expr *E = V->getInit()) {
475 const Expr *E = U->getSubExpr()->IgnoreParenCasts();
tools/clang/lib/StaticAnalyzer/Checkers/DeleteWithNonVirtualDtorChecker.cpp 63 const Expr *DeletedObj = DE->getArgument();
tools/clang/lib/StaticAnalyzer/Checkers/DereferenceChecker.cpp 45 const Expr *Ex, const ProgramState *state,
54 const Expr *Ex,
90 static const Expr *getDereferenceExpr(const Stmt *S, bool IsBind=false){
91 const Expr *E = nullptr;
95 if (const Expr *expr = dyn_cast<Expr>(S))
95 if (const Expr *expr = dyn_cast<Expr>(S))
100 const Expr *Init;
108 static bool suppressReport(const Expr *E) {
113 static bool isDeclRefExprToReference(const Expr *E) {
225 const Expr *expr = getDereferenceExpr(S);
267 const Expr *expr = getDereferenceExpr(S, /*IsBind=*/true);
tools/clang/lib/StaticAnalyzer/Checkers/DivZeroChecker.cpp 36 static const Expr *getDenomExpr(const ExplodedNode *N) {
tools/clang/lib/StaticAnalyzer/Checkers/DynamicTypePropagation.cpp 62 const ObjCObjectPointerType *getBetterObjCType(const Expr *CastE,
321 const Expr *RecE = MsgE->getInstanceReceiver();
344 DynamicTypePropagation::getBetterObjCType(const Expr *CastE,
610 static const Expr *stripCastsAndSugar(const Expr *E) {
610 static const Expr *stripCastsAndSugar(const Expr *E) {
767 const Expr *Arg = MessageExpr->getArg(i);
tools/clang/lib/StaticAnalyzer/Checkers/ExprInspectionChecker.cpp 112 const Expr *Assertion = CE->getArg(0);
tools/clang/lib/StaticAnalyzer/Checkers/GenericTaintChecker.cpp 112 static bool isStdin(const Expr *E, CheckerContext &C);
115 static Optional<SVal> getPointedToSVal(CheckerContext &C, const Expr *Arg);
149 bool generateReportIfTainted(const Expr *E, StringRef Msg,
211 static bool isTaintedOrPointsToTainted(const Expr *E, ProgramStateRef State,
516 const Expr *Arg = CE->getArg(ArgNum);
559 const Expr *Arg) {
635 const Expr *Arg = CE->getArg(i);
662 bool GenericTaintChecker::isStdin(const Expr *E, CheckerContext &C) {
721 bool GenericTaintChecker::generateReportIfTainted(const Expr *E, StringRef Msg,
tools/clang/lib/StaticAnalyzer/Checkers/IdenticalExprChecker.cpp 81 const Expr *LHS = B->getLHS();
82 const Expr *RHS = B->getRHS();
136 const Expr *Cond1 = I->getCond();
139 const Expr *Cond2 = I2->getCond();
222 const Expr *LHS = B->getLHS()->IgnoreParenImpCasts();
223 const Expr *RHS = B->getRHS()->IgnoreParenImpCasts();
318 const Expr *Expr1 = dyn_cast<Expr>(Stmt1);
318 const Expr *Expr1 = dyn_cast<Expr>(Stmt1);
319 const Expr *Expr2 = dyn_cast<Expr>(Stmt2);
319 const Expr *Expr2 = dyn_cast<Expr>(Stmt2);
332 Expr::const_child_iterator I1 = Expr1->child_begin();
333 Expr::const_child_iterator I2 = Expr2->child_begin();
tools/clang/lib/StaticAnalyzer/Checkers/InnerPointerChecker.cpp 138 const Expr *Origin = Call.getOriginExpr();
tools/clang/lib/StaticAnalyzer/Checkers/IteratorChecker.cpp 182 void handleComparison(CheckerContext &C, const Expr *CE, const SVal &RetVal,
197 void handleBegin(CheckerContext &C, const Expr *CE, const SVal &RetVal,
199 void handleEnd(CheckerContext &C, const Expr *CE, const SVal &RetVal,
201 void assignToContainer(CheckerContext &C, const Expr *CE, const SVal &RetVal,
204 const Expr *CE = nullptr,
303 const MemRegion *Cont, const Expr *E,
307 const Expr *E, QualType T,
579 const auto *OrigExpr = Call.getOriginExpr();
693 const auto *OrigExpr = Call.getOriginExpr();
851 void IteratorChecker::handleComparison(CheckerContext &C, const Expr *CE,
1138 void IteratorChecker::handleBegin(CheckerContext &C, const Expr *CE,
1160 void IteratorChecker::handleEnd(CheckerContext &C, const Expr *CE,
1182 void IteratorChecker::assignToContainer(CheckerContext &C, const Expr *CE,
1198 const Expr *CE, const SVal &OldCont) const {
1943 const MemRegion *Cont, const Expr *E,
1966 const Expr *E, QualType T,
tools/clang/lib/StaticAnalyzer/Checkers/IvarInvalidationChecker.cpp 121 const Expr *peel(const Expr *E) const;
121 const Expr *peel(const Expr *E) const;
124 bool isZero(const Expr *E) const;
142 void check(const Expr *E);
589 const Expr *IvarInvalidationCheckerImpl::MethodCrawler::peel(const Expr *E) const {
589 const Expr *IvarInvalidationCheckerImpl::MethodCrawler::peel(const Expr *E) const {
641 bool IvarInvalidationCheckerImpl::MethodCrawler::isZero(const Expr *E) const {
644 return (E->isNullPointerConstant(Ctx, Expr::NPC_ValueDependentIsNotNull)
645 != Expr::NPCK_NotNull);
648 void IvarInvalidationCheckerImpl::MethodCrawler::check(const Expr *E) {
693 const Expr *Receiver = ME->getInstanceReceiver();
tools/clang/lib/StaticAnalyzer/Checkers/LLVMConventionsChecker.cpp 151 Expr *Init = VD->getInit();
tools/clang/lib/StaticAnalyzer/Checkers/LocalizationChecker.cpp 1225 bool isCheckingPlurality(const Expr *E) const;
1242 const Expr *Condition) const {
1247 const Expr *InitExpr = VD->getInit();
1286 for (const Expr *Arg : CE->arguments()) {
1340 const Expr *Condition = I->getCond()->IgnoreParenImpCasts();
1370 const Expr *Condition = C->getCond()->IgnoreParenImpCasts();
tools/clang/lib/StaticAnalyzer/Checkers/MacOSKeychainAPIChecker.cpp 44 AllocationState(const Expr *E, unsigned int Idx, SymbolRef R) :
109 const Expr *ArgExpr,
159 static bool isEnclosingFunctionParam(const Expr *E) {
208 static SymbolRef getAsPointeeSymbol(const Expr *Expr,
226 const Expr *ArgExpr,
269 const Expr *ArgExpr = CE->getArg(paramIdx);
306 const Expr *ArgExpr = CE->getArg(paramIdx);
354 const Expr *DeallocatorExpr = CE->getArg(5)->IgnoreParenCasts();
357 Expr::NPC_ValueDependentIsNotNull)) {
416 const Expr *ArgExpr = CE->getArg(FunctionsToTrack[idx].Param);
643 const Expr *ArgExpr = CE->getArg(FunctionsToTrack[Idx].Param);
tools/clang/lib/StaticAnalyzer/Checkers/MallocChecker.cpp 103 const Expr *E);
109 CheckerContext &C, const Expr *E);
208 static ProgramStateRef MallocUpdateRefState(CheckerContext &C, const Expr *E,
414 static ProgramStateRef ProcessZeroAllocCheck(CheckerContext &C, const Expr *E,
450 const Expr *SizeEx, SVal Init,
541 ProgramStateRef FreeMemAux(CheckerContext &C, const Expr *ArgExpr,
542 const Expr *ParentExpr, ProgramStateRef State,
568 static SVal evalMulForBufferSize(CheckerContext &C, const Expr *Blocks,
569 const Expr *BlockBytes);
635 const Expr *DeallocExpr) const;
639 const Expr *DeallocExpr, const RefState *RS,
642 const Expr *DeallocExpr,
643 const Expr *AllocExpr = nullptr) const;
655 SourceRange Range, const Expr *FreeExpr) const;
775 std::string getMessageForArg(const Expr *ArgE, unsigned ArgIndex) override {
1012 const Expr *FlagsEx = CE->getArg(CE->getNumArgs() - 1);
1044 SVal MallocChecker::evalMulForBufferSize(CheckerContext &C, const Expr *Blocks,
1045 const Expr *BlockBytes) {
1231 CheckerContext &C, const Expr *E, const unsigned IndexOfSizeArg,
1239 const Expr *Arg = nullptr;
1386 const Expr *SizeExpr = *NE->getArraySize();
1501 const Expr *SizeEx, SVal Init,
1554 static ProgramStateRef MallocUpdateRefState(CheckerContext &C, const Expr *E,
1680 const Expr *E) {
1721 CheckerContext &C, const Expr *E) {
1748 const Expr *ArgExpr,
1749 const Expr *ParentExpr,
1864 const Expr *AllocExpr = cast<Expr>(RsBase->getStmt());
1864 const Expr *AllocExpr = cast<Expr>(RsBase->getStmt());
2047 const Expr *DeallocExpr) const {
2120 const Expr *DeallocExpr,
2137 const Expr *AllocExpr = cast<Expr>(RS->getStmt());
2137 const Expr *AllocExpr = cast<Expr>(RS->getStmt());
2175 SourceRange Range, const Expr *DeallocExpr,
2176 const Expr *AllocExpr) const {
2358 const Expr *FreeExpr) const {
2405 const Expr *arg0Expr = CE->getArg(0);
2417 const Expr *Arg1 = CE->getArg(1);
2740 const Expr *E = S->getRetValue();
2827 for (const Expr *Arg : CE->arguments())
3019 const Expr *ArgE = Call->getArgExpr(i)->IgnoreParenCasts();
3043 const Expr *ArgE = Call->getArgExpr(0)->IgnoreParenCasts();
3385 markReleased(ProgramStateRef State, SymbolRef Sym, const Expr *Origin) {
tools/clang/lib/StaticAnalyzer/Checkers/MallocOverflowSecurityChecker.cpp 36 const Expr *variable;
39 MallocOverflowCheck(const BinaryOperator *m, const Expr *v, APSInt val)
50 const Expr *TheArgument, ASTContext &Context) const;
66 const Expr *TheArgument,
74 const Expr *e = TheArgument;
89 const Expr *lhs = binop->getLHS();
90 const Expr *rhs = binop->getRHS();
134 bool isIntZeroExpr(const Expr *E) const {
137 Expr::EvalResult Result;
160 void CheckExpr(const Expr *E_p) {
162 const Expr *E = E_p->IgnoreParenImpCasts();
182 const Expr *rhs = AssignEx->getRHS();
189 const Expr *rhse = rhs->IgnoreParenImpCasts();
192 const Expr *denom = BOp->getRHS()->IgnoreParenImpCasts();
193 Expr::EvalResult Result;
198 const Expr *numerator = BOp->getLHS()->IgnoreParenImpCasts();
211 const Expr *lhs = AssignEx->getLHS();
212 const Expr *E = lhs->IgnoreParenImpCasts();
229 const Expr * lhs = E->getLHS();
230 const Expr * rhs = E->getRHS();
tools/clang/lib/StaticAnalyzer/Checkers/MallocSizeofChecker.cpp 40 const Expr *CastedExpr;
44 CallRecord(ExprParent CastedExprParent, const Expr *CastedExpr,
62 Calls.push_back(CallRecord(Parent, cast<Expr>(S), AllocCall.first,
104 if (const Expr *Init = VD->getInit())
tools/clang/lib/StaticAnalyzer/Checkers/NoReturnFunctionChecker.cpp 47 const Expr *Callee = CE.getOriginExpr();
tools/clang/lib/StaticAnalyzer/Checkers/NonNullParamChecker.cpp 40 const Expr *ArgE,
44 const Expr *ArgE) const;
97 const Expr *ArgE = Call.getArgExpr(idx);
134 ArgE = dyn_cast<Expr>(*(IE->begin()));
184 const Expr *ArgE,
209 const ExplodedNode *ErrorNode, const Expr *ArgE) const {
216 const Expr *ArgEDeref = bugreporter::getDerefExpr(ArgE);
tools/clang/lib/StaticAnalyzer/Checkers/NullabilityChecker.cpp 176 if (const auto *Ex = dyn_cast<Expr>(ValueExpr))
176 if (const auto *Ex = dyn_cast<Expr>(ValueExpr))
510 static const Expr *lookThroughImplicitCasts(const Expr *E) {
510 static const Expr *lookThroughImplicitCasts(const Expr *E) {
659 const Expr *ArgExpr = Call.getArgExpr(Idx);
987 static const Expr * matchValueExprForBind(const Stmt *S) {
1001 if (const Expr *Init = VD->getInit())
1041 const Expr *Init = VD->getInit();
1083 const Expr *ValueExpr = matchValueExprForBind(S);
tools/clang/lib/StaticAnalyzer/Checkers/NumberObjectConversionChecker.cpp 72 if (const Expr *CheckIfNull =
73 Result.Nodes.getNodeAs<Expr>("check_if_null")) {
89 Expr::EvalResult EVResult;
91 EVResult, ACtx, Expr::SE_AllowSideEffects)) {
105 const Expr *ConvertedCObject = Result.Nodes.getNodeAs<Expr>("c_object");
105 const Expr *ConvertedCObject = Result.Nodes.getNodeAs<Expr>("c_object");
106 const Expr *ConvertedCppObject = Result.Nodes.getNodeAs<Expr>("cpp_object");
106 const Expr *ConvertedCppObject = Result.Nodes.getNodeAs<Expr>("cpp_object");
107 const Expr *ConvertedObjCObject = Result.Nodes.getNodeAs<Expr>("objc_object");
107 const Expr *ConvertedObjCObject = Result.Nodes.getNodeAs<Expr>("objc_object");
110 const Expr *Obj = IsObjC ? ConvertedObjCObject
tools/clang/lib/StaticAnalyzer/Checkers/ObjCAtSyncChecker.cpp 39 const Expr *Ex = S->getSynchExpr();
tools/clang/lib/StaticAnalyzer/Checkers/ObjCAutoreleaseWriteChecker.cpp 118 const auto *MarkedStmt = Match.getNodeAs<Expr>(ProblematicWriteBind);
118 const auto *MarkedStmt = Match.getNodeAs<Expr>(ProblematicWriteBind);
123 MarkedStmt = Match.getNodeAs<Expr>(CapturedBind);
tools/clang/lib/StaticAnalyzer/Checkers/ObjCContainersASTChecker.cpp 44 inline bool hasPointerToPointerSizedType(const Expr *E) {
69 E->isNullPointerConstant(ASTC, Expr::NPC_ValueDependentIsNull));
101 const Expr *Arg = nullptr;
tools/clang/lib/StaticAnalyzer/Checkers/ObjCContainersChecker.cpp 40 inline SymbolRef getArraySym(const Expr *E, CheckerContext &C) const {
46 void addSizeInfo(const Expr *Array, const Expr *Size,
46 void addSizeInfo(const Expr *Array, const Expr *Size,
68 void ObjCContainersChecker::addSizeInfo(const Expr *Array, const Expr *Size,
68 void ObjCContainersChecker::addSizeInfo(const Expr *Array, const Expr *Size,
121 const Expr *ArrayExpr = CE->getArg(0);
132 const Expr *IdxExpr = CE->getArg(1);
tools/clang/lib/StaticAnalyzer/Checkers/ObjCSelfInitChecker.cpp 66 void checkForInvalidSelf(const Expr *E, CheckerContext &C,
133 static bool isInvalidSelf(const Expr *E, CheckerContext &C) {
143 void ObjCSelfInitChecker::checkForInvalidSelf(const Expr *E, CheckerContext &C,
tools/clang/lib/StaticAnalyzer/Checkers/ObjCUnusedIVarsChecker.cpp 53 const Expr *sub = *i;
tools/clang/lib/StaticAnalyzer/Checkers/PointerArithChecker.cpp 54 void reportPointerArithMisuse(const Expr *E, CheckerContext &C,
148 void PointerArithChecker::reportPointerArithMisuse(const Expr *E,
262 const Expr *CastedExpr = CE->getSubExpr();
280 const Expr *CastedExpr = CE->getSubExpr();
323 const Expr *Lhs = BOp->getLHS();
324 const Expr *Rhs = BOp->getRHS();
tools/clang/lib/StaticAnalyzer/Checkers/RetainCountChecker/RetainCountChecker.cpp 230 const Expr *Ex) const {
355 const Expr *CE = Call.getOriginExpr();
394 static QualType GetReturnType(const Expr *RetE, ASTContext &Ctx) {
691 const Expr *Ex = CallOrMsg.getOriginExpr();
922 const Expr *BindReturnTo =
978 const Expr *RetE = S->getRetValue();
tools/clang/lib/StaticAnalyzer/Checkers/RetainCountChecker/RetainCountChecker.h 345 void processObjCLiterals(CheckerContext &C, const Expr *Ex) const;
tools/clang/lib/StaticAnalyzer/Checkers/RetainCountChecker/RetainCountDiagnostics.cpp 71 static bool isNumericLiteralExpression(const Expr *E) {
185 static Optional<std::string> findMetaClassAlloc(const Expr *Callee) {
189 const Expr *This = ME->getBase()->IgnoreParenImpCasts();
573 if (const Expr *receiver = ME->getInstanceReceiver()) {
597 if (const Expr *Exp = dyn_cast_or_null<Expr>(Child))
597 if (const Expr *Exp = dyn_cast_or_null<Expr>(Child))
tools/clang/lib/StaticAnalyzer/Checkers/ReturnPointerRangeChecker.cpp 38 const Expr *RetE = RS->getRetValue();
tools/clang/lib/StaticAnalyzer/Checkers/ReturnUndefChecker.cpp 30 void emitUndef(CheckerContext &C, const Expr *RetE) const;
31 void checkReference(CheckerContext &C, const Expr *RetE,
40 const Expr *RetE = RS->getRetValue();
80 static void emitBug(CheckerContext &C, BuiltinBug &BT, const Expr *RetE,
81 const Expr *TrackingE = nullptr) {
95 void ReturnUndefChecker::emitUndef(CheckerContext &C, const Expr *RetE) const {
103 void ReturnUndefChecker::checkReference(CheckerContext &C, const Expr *RetE,
tools/clang/lib/StaticAnalyzer/Checkers/StackAddrEscapeChecker.cpp 57 const Expr *RetE) const;
84 const Expr *ARE = AR->getExpr();
153 const Expr *RetE) const {
253 const Expr *RetE = RS->getRetValue();
tools/clang/lib/StaticAnalyzer/Checkers/TaintTesterChecker.cpp 25 class TaintTesterChecker : public Checker< check::PostStmt<Expr> > {
33 const Expr* Arg,
37 void checkPostStmt(const Expr *E, CheckerContext &C) const;
46 void TaintTesterChecker::checkPostStmt(const Expr *E,
tools/clang/lib/StaticAnalyzer/Checkers/TestAfterDivZeroChecker.cpp 101 const Expr *E = nullptr;
tools/clang/lib/StaticAnalyzer/Checkers/TraversalChecker.cpp 96 const Expr *CallE = Call.getOriginExpr();
tools/clang/lib/StaticAnalyzer/Checkers/UndefBranchChecker.cpp 36 const Expr *FindExpr(const Expr *Ex) {
36 const Expr *FindExpr(const Expr *Ex) {
41 if (const Expr *ExI = dyn_cast_or_null<Expr>(SubStmt))
41 if (const Expr *ExI = dyn_cast_or_null<Expr>(SubStmt))
42 if (const Expr *E2 = FindExpr(ExI))
48 bool MatchesCriteria(const Expr *Ex) {
86 const Expr *Ex = cast<Expr>(Condition);
86 const Expr *Ex = cast<Expr>(Condition);
tools/clang/lib/StaticAnalyzer/Checkers/UndefCapturedBlockVarChecker.cpp 87 if (const Expr *Ex = FindBlockDeclRefExpr(BE->getBody(), VD))
tools/clang/lib/StaticAnalyzer/Checkers/UndefResultChecker.cpp 37 static bool isArrayIndexOutOfBounds(CheckerContext &C, const Expr *Ex) {
98 const Expr *Ex = nullptr;
tools/clang/lib/StaticAnalyzer/Checkers/UndefinedArraySubscriptChecker.cpp 37 const Expr *Index = A->getIdx();
tools/clang/lib/StaticAnalyzer/Checkers/UndefinedAssignmentChecker.cpp 62 const Expr *ex = nullptr;
tools/clang/lib/StaticAnalyzer/Checkers/UnixAPIChecker.cpp 80 const Expr *arg,
188 const Expr *Arg = CE->getArg(CreateModeArgIndex);
230 const Expr *oflagsEx = CE->getArg(FlagsArgIndex);
339 const Expr *arg,
375 const Expr *arg = CE->getArg(sizeArg);
403 const Expr *arg = CE->getArg(i);
tools/clang/lib/StaticAnalyzer/Checkers/VLASizeChecker.cpp 36 void reportBug(VLASize_Kind Kind, const Expr *SizeE, ProgramStateRef State,
46 VLASize_Kind Kind, const Expr *SizeE, ProgramStateRef State,
96 const Expr *SE = VLA->getSizeExpr();
tools/clang/lib/StaticAnalyzer/Checkers/ValistChecker.cpp 56 const MemRegion *getVAListAsRegion(SVal SV, const Expr *VAExpr,
163 const MemRegion *ValistChecker::getVAListAsRegion(SVal SV, const Expr *E,
189 const Expr *VASubExpr = VAA->getSubExpr();
tools/clang/lib/StaticAnalyzer/Checkers/VirtualCallChecker.cpp 71 if (const Expr *Base = CME->getBase()) {
tools/clang/lib/StaticAnalyzer/Core/BugReporter.cpp 328 std::string StackHintGeneratorForSymbol::getMessageForArg(const Expr *ArgE,
614 if (isa<Expr>(S) && PM.isConsumedExpr(cast<Expr>(S)))
614 if (isa<Expr>(S) && PM.isConsumedExpr(cast<Expr>(S)))
764 const Expr *LHS = Case->getLHS()->IgnoreParenCasts();
1845 if (isa<Expr>(s1End) && PM.isConsumedExpr(cast<Expr>(s1End))) {
1845 if (isa<Expr>(s1End) && PM.isConsumedExpr(cast<Expr>(s1End))) {
2331 if (Ranges.empty() && isa_and_nonnull<Expr>(getStmt()))
tools/clang/lib/StaticAnalyzer/Core/BugReporterVisitors.cpp 74 static const Expr *peelOffPointerArithmetic(const BinaryOperator *B) {
97 const Expr *bugreporter::getDerefExpr(const Stmt *S) {
98 const auto *E = dyn_cast<Expr>(S);
98 const auto *E = dyn_cast<Expr>(S);
111 if (const Expr *Inner = peelOffPointerArithmetic(B)) {
183 static Optional<SVal> getSValForVar(const Expr *CondVarExpr,
208 getConcreteIntegerValue(const Expr *CondVarExpr, const ExplodedNode *N) {
216 static bool isVarAnInterestingCondition(const Expr *CondVarExpr,
232 static bool isInterestingExpr(const Expr *E, const ExplodedNode *N,
453 const Expr *Base = IvarRef->getBase();
861 if (const Expr *RHS = VD->getInit())
867 const Expr *RHS = BO->getRHS();
985 if (cast<Expr>(S)->isGLValue())
1028 const Expr *RetE = Ret->getRetValue();
1158 const Expr *ArgE = Call->getArgExpr(I);
1369 const Expr *InitE = nullptr;
1734 constructDebugPieceForTrackedCondition(const Expr *Cond,
1814 if (const Expr *Condition = NB->getLastCondition()) {
1834 static const MemRegion *getLocationRegionIfReference(const Expr *E,
1857 static const Expr *peelOffOuterExpr(const Expr *Ex,
1857 static const Expr *peelOffOuterExpr(const Expr *Ex,
1867 const Expr *GetterMessageSend =
1898 if (const Expr *SubEx = peelOffPointerArithmetic(BO))
1914 if (const Expr *DerefEx = bugreporter::getDerefExpr(UO->getSubExpr()))
1924 const Expr *Inner) {
1934 const Expr *E,
1942 const Expr *Inner = peelOffOuterExpr(E, InputNode);
1962 if (const Expr *Receiver = NilReceiverBRVisitor::getNilReceiver(Inner, LVNode))
2080 const Expr *NilReceiverBRVisitor::getNilReceiver(const Stmt *S,
2085 if (const Expr *Receiver = ME->getInstanceReceiver()) {
2102 const Expr *Receiver = getNilReceiver(S, N);
2184 return VisitTrueTest(cast<Expr>(PS->getStmt()), BRC, BR, N, TookTrue);
2194 const Expr *Cond = nullptr;
2249 ConditionBRVisitor::VisitTrueTest(const Expr *Cond, BugReporterContext &BRC,
2266 const Expr *CondTmp = Cond;
2317 bool ConditionBRVisitor::patternMatch(const Expr *Ex,
2318 const Expr *ParentEx,
2325 const Expr *OriginalExpr = Ex;
2405 const Expr *Cond, const BinaryOperator *BExpr, BugReporterContext &BRC,
2525 StringRef LhsString, const Expr *CondVarExpr, BugReporterContext &BRC,
2552 const Expr *Cond, const DeclRefExpr *DRE, BugReporterContext &BRC,
2588 const Expr *Cond, const MemberExpr *ME, BugReporterContext &BRC,
2625 bool ConditionBRVisitor::printValue(const Expr *CondVarExpr, raw_ostream &Out,
tools/clang/lib/StaticAnalyzer/Core/CallEvent.cpp 71 const Expr *E = getOriginExpr();
200 const Expr *E = getOriginExpr();
342 if (const Expr *E = getOriginExpr()) {
416 const Expr *ArgE = getArgExpr(Index);
423 const Expr *ArgE = getArgExpr(Index);
430 const Expr *E = getOriginExpr();
440 if (const Expr *E = getOriginExpr()) {
694 const Expr *Ex = getCXXThisExpr()->ignoreParenBaseCasts();
713 const Expr *Base = getCXXThisExpr();
827 const Expr *CXXMemberCall::getCXXThisExpr() const {
843 const Expr *CXXMemberOperatorCall::getCXXThisExpr() const {
848 const Expr *Callee = getOriginExpr()->getCallee();
982 if (const Expr *RecE = getOriginExpr()->getInstanceReceiver())
1025 static const Expr *
1027 const Expr *Syntactic = POE->getSyntacticForm();
1045 const Expr *Syntactic = getSyntacticFromForPseudoObjectExpr(POE);
1087 const Expr *Syntactic = getSyntacticFromForPseudoObjectExpr(POE);
1171 const Expr* InstRec = ME->getInstanceReceiver();
tools/clang/lib/StaticAnalyzer/Core/CheckerContext.cpp 22 const Expr *Callee = CE->getCallee();
123 bool CheckerContext::isGreaterOrEqual(const Expr *E, unsigned long long Val) {
128 bool CheckerContext::isNegative(const Expr *E) {
tools/clang/lib/StaticAnalyzer/Core/CheckerHelpers.cpp 79 std::pair<const clang::VarDecl *, const clang::Expr *>
82 const Expr *RHS = nullptr;
tools/clang/lib/StaticAnalyzer/Core/Environment.cpp 37 static const Expr *ignoreTransparentExprs(const Expr *E) {
37 static const Expr *ignoreTransparentExprs(const Expr *E) {
65 if (const auto *E = dyn_cast<Expr>(S))
65 if (const auto *E = dyn_cast<Expr>(S))
113 return svalBuilder.getConstantVal(cast<Expr>(S)).getValue();
117 if (const Expr *RE = RS->getRetValue())
tools/clang/lib/StaticAnalyzer/Core/ExplodedGraph.cpp 50 bool ExplodedGraph::isInterestingLValueExpr(const Expr *Ex) {
124 const Expr *Ex = dyn_cast<Expr>(progPoint.castAs<PostStmt>().getStmt());
124 const Expr *Ex = dyn_cast<Expr>(progPoint.castAs<PostStmt>().getStmt());
tools/clang/lib/StaticAnalyzer/Core/ExprEngine.cpp 311 const Expr *InitWithAdjustments, const Expr *Result,
311 const Expr *InitWithAdjustments, const Expr *Result,
361 SmallVector<const Expr *, 2> CommaLHSs;
364 const Expr *Init = InitWithAdjustments->skipRValueSubobjectAdjustments(
676 if (!isa<Expr>(S))
686 return !PM.isConsumedExpr(cast<Expr>(S));
819 const Expr *Init = BMI->getInit()->IgnoreImplicit();
1207 case Expr::ObjCIndirectCopyRestoreExprClass:
1314 case Expr::MSDependentExistsStmtClass:
1336 case Expr::ConstantExprClass:
1419 const Expr *ArgE;
1443 cast<Expr>(S),
1444 cast<Expr>(S));
1455 case Expr::ObjCArrayLiteralClass:
1456 case Expr::ObjCDictionaryLiteralClass:
1457 case Expr::ObjCBoxedExprClass: {
1466 const auto *Ex = cast<Expr>(S);
1466 const auto *Ex = cast<Expr>(S);
1553 evalEagerlyAssumeBinOpBifurcation(Dst, Tmp, cast<Expr>(S));
1707 case Expr::MaterializeTemporaryExprClass: {
1800 if (const auto *LastExpr =
1801 dyn_cast<Expr>(*SE->getSubStmt()->body_rbegin())) {
1829 if (const Expr *Result = PE->getResultExpr()) {
1995 const auto *Ex = dyn_cast<Expr>(Condition);
1995 const auto *Ex = dyn_cast<Expr>(Condition);
2056 if (const auto *Ex = dyn_cast<Expr>(Condition))
2056 if (const auto *Ex = dyn_cast<Expr>(Condition))
2107 if (const auto *Ex = dyn_cast<Expr>(Condition))
2107 if (const auto *Ex = dyn_cast<Expr>(Condition))
2132 if (const auto *Ex = dyn_cast<Expr>(Condition)) {
2132 if (const auto *Ex = dyn_cast<Expr>(Condition)) {
2340 const Expr *CondE = builder.getCondition();
2370 if (const Expr *E = Case->getRHS())
2406 const Expr *CondExpr = SS->getCond()->IgnoreParenImpCasts();
2419 void ExprEngine::VisitCommonDeclRefExpr(const Expr *Ex, const NamedDecl *D,
2513 const Expr *Base = A->getBase()->IgnoreParens();
2514 const Expr *Idx = A->getIdx()->IgnoreParens();
2582 Expr *BaseExpr = M->getBase();
2658 const Expr *SubExpr = AE->getSubExprs()[SI];
2816 void ExprEngine::evalStore(ExplodedNodeSet &Dst, const Expr *AssignE,
2817 const Expr *LocationE,
2823 const Expr *StoreE = AssignE ? AssignE : LocationE;
2840 const Expr *NodeEx,
2841 const Expr *BoundEx,
2925 const Expr *Ex) {
2976 for (const Expr *O : A->outputs()) {
tools/clang/lib/StaticAnalyzer/Core/ExprEngineC.cpp 29 SVal Symbol, SVal Other, Expr* Expression, SValBuilder &svalBuilder,
44 Expr *LHS = B->getLHS()->IgnoreParens();
45 Expr *RHS = B->getRHS()->IgnoreParens();
229 const Expr *copyExpr = nullptr;
260 ProgramStateRef state, const Expr* Ex, const LocationContext* LCtx,
301 void ExprEngine::VisitCast(const CastExpr *CastE, const Expr *Ex,
557 const Expr *Init = CL->getInitializer();
598 if (const Expr *InitEx = VD->getInit()) {
714 const Expr *RHS = cast<Expr>(Elem.getStmt());
714 const Expr *RHS = cast<Expr>(Elem.getStmt());
757 SVal V = state->getSVal(cast<Expr>(*it), LCtx);
781 void ExprEngine::VisitGuardedExpr(const Expr *Ex,
782 const Expr *L,
783 const Expr *R,
819 const Expr *ValEx = cast<Expr>(CS->getStmt());
819 const Expr *ValEx = cast<Expr>(CS->getStmt());
849 Expr::EvalResult Result;
917 const Expr *Ex = U->getSubExpr()->IgnoreParens();
944 const Expr *Ex = U->getSubExpr()->IgnoreParens();
962 const Expr *Ex = U->getSubExpr()->IgnoreParens();
978 const Expr *Ex = U->getSubExpr()->IgnoreParens();
1007 const Expr *Ex = U->getSubExpr()->IgnoreParens();
1065 const Expr *Ex = U->getSubExpr()->IgnoreParens();
tools/clang/lib/StaticAnalyzer/Core/ExprEngineCXX.cpp 30 const Expr *tempExpr = ME->GetTemporaryExpr()->IgnoreParens();
82 const Expr *CallExpr = Call.getOriginExpr();
113 const Expr *E, ProgramStateRef State, const LocationContext *LCtx,
206 cast<Expr>(SFC->getCallSite()), State, CallerLCtx,
222 const Expr *RetE = RCC->getReturnStmt()->getRetValue();
319 const Expr *E = ACC->getCallLikeExpr();
635 if (const Expr *E = dyn_cast_or_null<Expr>(S)) {
635 if (const Expr *E = dyn_cast_or_null<Expr>(S)) {
837 if (const Expr *Init = CNE->getInitializer()) {
911 Expr *InitExpr = *i;
918 Expr *SizeExpr = FieldForCapture->getCapturedVLAType()->getSizeExpr();
tools/clang/lib/StaticAnalyzer/Core/ExprEngineCallAndReturn.cpp 237 if (const Expr *Ex = dyn_cast<Expr>(CE)) {
237 if (const Expr *Ex = dyn_cast<Expr>(CE)) {
449 const Expr *CallE = Call.getOriginExpr();
526 const Expr *E = Call.getOriginExpr();
559 const Expr *E = Call.getOriginExpr();
603 const Expr *E = Call.getOriginExpr();
1018 const Expr *E = Call->getOriginExpr();
tools/clang/lib/StaticAnalyzer/Core/LoopWidening.cpp 28 static const Expr *getLoopCondition(const Stmt *LoopStmt) {
tools/clang/lib/StaticAnalyzer/Core/MemRegion.cpp 266 const Expr *Ex, unsigned cnt,
387 Expr const *Ex,
967 MemRegionManager::getCXXStaticTempObjectRegion(const Expr *Ex) {
1044 MemRegionManager::getCXXTempObjectRegion(Expr const *E,
1121 MemRegionManager::getAllocaRegion(const Expr *E, unsigned cnt,
tools/clang/lib/StaticAnalyzer/Core/ProgramState.cpp 157 const Expr *E, unsigned Count,
174 const Expr *E, unsigned Count,
187 const Expr *E, unsigned Count,
tools/clang/lib/StaticAnalyzer/Core/RegionStore.cpp 419 const Expr *Ex,
427 const Expr *E, unsigned Count,
996 const Expr *Ex;
1007 const Expr *ex, unsigned count,
1281 const Expr *Ex,
1337 const Expr *Ex, unsigned Count,
1711 if (const Expr *Init = VD->getAnyInitializer()) {
1729 if (const Expr *ElemInit = InitList->getInit(i))
1789 if (const Expr *Init = FD->getInClassInitializer())
1804 if (const Expr *Init = VD->getAnyInitializer())
1807 if (const Expr *FieldInit = InitList->getInit(Index))
2002 if (const Expr *Init = VD->getAnyInitializer()) {
2023 if (const Expr *Init = VD->getAnyInitializer())
tools/clang/lib/StaticAnalyzer/Core/SValBuilder.cpp 136 const Expr *Ex,
154 const Expr *expr,
191 SValBuilder::getConjuredHeapSymbolVal(const Expr *E,
206 const Expr *expr, QualType type,
285 Optional<SVal> SValBuilder::getConstantVal(const Expr *E) {
346 const Expr *SE = CE->getSubExpr();
364 Expr::EvalResult Result;
369 if (E->isNullPointerConstant(Ctx, Expr::NPC_ValueDependentIsNotNull))
tools/clang/lib/Tooling/ASTDiff/ASTDiff.cpp 240 if (auto *E = dyn_cast_or_null<Expr>(S))
240 if (auto *E = dyn_cast_or_null<Expr>(S))
tools/clang/lib/Tooling/Refactoring/Extract/Extract.cpp 30 bool isSimpleExpression(const Expr *E) {
81 if (isSimpleExpression(dyn_cast<Expr>(Code[0])))
119 bool IsExpr = Code.size() == 1 && isa<Expr>(Code[0]);
122 ReturnType = cast<Expr>(Code[0])->getType();
tools/clang/lib/Tooling/Refactoring/Extract/SourceExtraction.cpp 85 if (isa<Expr>(S))
tools/clang/lib/Tooling/Transformer/RangeSelector.cpp 134 return Node->get<Stmt>() != nullptr && Node->get<Expr>() == nullptr
tools/clang/lib/Tooling/Transformer/SourceCodeBuilders.cpp 20 const Expr *tooling::reallyIgnoreImplicit(const Expr &E) {
20 const Expr *tooling::reallyIgnoreImplicit(const Expr &E) {
21 const Expr *Expr = E.IgnoreImplicit();
30 bool tooling::mayEverNeedParens(const Expr &E) {
31 const Expr *Expr = reallyIgnoreImplicit(E);
50 bool tooling::needParensAfterUnaryOperator(const Expr &E) {
51 const Expr *Expr = reallyIgnoreImplicit(E);
63 llvm::Optional<std::string> tooling::buildParens(const Expr &E,
74 tooling::buildDereference(const Expr &E, const ASTContext &Context) {
94 llvm::Optional<std::string> tooling::buildAddressOf(const Expr &E,
115 llvm::Optional<std::string> tooling::buildDot(const Expr &E,
120 const Expr *SubExpr = Op->getSubExpr()->IgnoreParenImpCasts();
139 llvm::Optional<std::string> tooling::buildArrow(const Expr &E,
144 const Expr *SubExpr = Op->getSubExpr()->IgnoreParenImpCasts();
tools/clang/lib/Tooling/Transformer/Stencil.cpp 167 const auto *E = Match.Nodes.getNodeAs<Expr>(Data.Id);
167 const auto *E = Match.Nodes.getNodeAs<Expr>(Data.Id);
202 const auto *E = Match.Nodes.getNodeAs<Expr>(Data.BaseId);
202 const auto *E = Match.Nodes.getNodeAs<Expr>(Data.BaseId);
tools/clang/tools/clang-extdef-mapping/ClangExtDefMapGen.cpp 68 if (const Expr *Init = VD->getInit())
tools/clang/tools/extra/clang-tidy/abseil/DurationConversionCastCheck.cpp 44 const auto *Arg = Result.Nodes.getNodeAs<Expr>("arg");
44 const auto *Arg = Result.Nodes.getNodeAs<Expr>("arg");
tools/clang/tools/extra/clang-tidy/abseil/DurationFactoryFloatCheck.cpp 51 const Expr *Arg = MatchedCall->getArg(0)->IgnoreImpCasts();
tools/clang/tools/extra/clang-tidy/abseil/DurationFactoryScaleCheck.cpp 147 const Expr *Arg = Call->getArg(0)->IgnoreParenImpCasts();
168 const Expr *Remainder;
205 const Expr *Remainder = DivBinOp->getLHS();
tools/clang/tools/extra/clang-tidy/abseil/DurationRewriter.cpp 72 DurationScale Scale, const Expr &Node) {
75 if (const auto *MaybeCallArg = selectFirst<const Expr>(
75 if (const auto *MaybeCallArg = selectFirst<const Expr>(
91 DurationScale Scale, const Expr &Node) {
93 if (const auto *MaybeCallArg = selectFirst<const Expr>(
93 if (const auto *MaybeCallArg = selectFirst<const Expr>(
160 bool IsLiteralZero(const MatchFinder::MatchResult &Result, const Expr &Node) {
165 if (selectFirst<const clang::Expr>(
172 if (selectFirst<const clang::Expr>(
187 const Expr &Node) {
188 if (const Expr *MaybeCastArg = selectFirst<const Expr>(
188 if (const Expr *MaybeCastArg = selectFirst<const Expr>(
207 const Expr &Node) {
217 const Expr &Node) {
271 const Expr *Node) {
272 const Expr &RootNode = *Node->IgnoreParenImpCasts();
289 const Expr *Node) {
290 const Expr &RootNode = *Node->IgnoreParenImpCasts();
305 bool isInMacro(const MatchFinder::MatchResult &Result, const Expr *E) {
tools/clang/tools/extra/clang-tidy/abseil/DurationRewriter.h 40 const Expr &Node);
48 const Expr &Node);
56 const Expr &Node);
63 const Expr &Node);
86 const Expr *Node);
92 const Expr *Node);
97 const Expr *E);
tools/clang/tools/extra/clang-tidy/abseil/DurationSubtractionCheck.cpp 48 const Expr *LhsArg = Result.Nodes.getNodeAs<Expr>("lhs_arg");
48 const Expr *LhsArg = Result.Nodes.getNodeAs<Expr>("lhs_arg");
tools/clang/tools/extra/clang-tidy/abseil/DurationUnnecessaryConversionCheck.cpp 66 const auto *OuterCall = Result.Nodes.getNodeAs<Expr>("call");
66 const auto *OuterCall = Result.Nodes.getNodeAs<Expr>("call");
67 const auto *Arg = Result.Nodes.getNodeAs<Expr>("arg");
67 const auto *Arg = Result.Nodes.getNodeAs<Expr>("arg");
tools/clang/tools/extra/clang-tidy/abseil/FasterStrsplitDelimiterCheck.cpp 114 if (const auto *ByAnyChar = Result.Nodes.getNodeAs<Expr>("ByAnyChar"))
114 if (const auto *ByAnyChar = Result.Nodes.getNodeAs<Expr>("ByAnyChar"))
tools/clang/tools/extra/clang-tidy/abseil/RedundantStrcatCallsCheck.cpp 62 const clang::CallExpr* ProcessArgument(const Expr* Arg,
93 for (const auto *Arg : CallExpr->arguments()) {
tools/clang/tools/extra/clang-tidy/abseil/StringFindStartswithCheck.cpp 67 const auto *Needle = Result.Nodes.getNodeAs<Expr>("needle");
67 const auto *Needle = Result.Nodes.getNodeAs<Expr>("needle");
69 const Expr *Haystack = Result.Nodes.getNodeAs<CXXMemberCallExpr>("findexpr")
tools/clang/tools/extra/clang-tidy/abseil/TimeSubtractionCheck.cpp 31 const Expr *Node) {
36 return selectFirst<const Expr>(
48 const Expr *Node) {
51 return selectFirst<const Expr>(
66 static bool isReturn(const MatchFinder::MatchResult &Result, const Expr *Node) {
69 return selectFirst<const Expr>(
81 const Expr *Node) {
88 void TimeSubtractionCheck::emitDiagnostic(const Expr *Node,
tools/clang/tools/extra/clang-tidy/abseil/TimeSubtractionCheck.h 31 void emitDiagnostic(const Expr* Node, llvm::StringRef Replacement);
tools/clang/tools/extra/clang-tidy/abseil/UpgradeDurationConversionsCheck.cpp 122 const auto *ArgExpr = Result.Nodes.getNodeAs<Expr>("arg");
122 const auto *ArgExpr = Result.Nodes.getNodeAs<Expr>("arg");
125 const auto *OuterExpr = Result.Nodes.getNodeAs<Expr>("OuterExpr");
125 const auto *OuterExpr = Result.Nodes.getNodeAs<Expr>("OuterExpr");
tools/clang/tools/extra/clang-tidy/android/CloexecCheck.cpp 25 std::string buildFixMsgForStringFlag(const Expr *Arg, const SourceManager &SM,
56 const auto *FlagArg = MatchedCall->getArg(ArgPos);
86 const auto *ModeArg = MatchedCall->getArg(ArgPos);
tools/clang/tools/extra/clang-tidy/bugprone/ArgumentCommentCheck.cpp 229 bool ArgumentCommentCheck::shouldAddComment(const Expr *Arg) const {
247 llvm::ArrayRef<const Expr *> Args) {
330 const auto *E = Result.Nodes.getNodeAs<Expr>("expr");
330 const auto *E = Result.Nodes.getNodeAs<Expr>("expr");
tools/clang/tools/extra/clang-tidy/bugprone/ArgumentCommentCheck.h 56 llvm::ArrayRef<const Expr *> Args);
58 bool shouldAddComment(const Expr *Arg) const;
tools/clang/tools/extra/clang-tidy/bugprone/AssertSideEffectCheck.cpp 29 const Expr *E = &Node;
tools/clang/tools/extra/clang-tidy/bugprone/DanglingHandleCheck.cpp 26 const ast_matchers::internal::Matcher<Expr> &Arg) {
tools/clang/tools/extra/clang-tidy/bugprone/DynamicStaticInitializersCheck.cpp 20 const Expr *Init = Node.getInit();
tools/clang/tools/extra/clang-tidy/bugprone/InfiniteLoopCheck.cpp 169 const auto *Cond = Result.Nodes.getNodeAs<Expr>("condition");
169 const auto *Cond = Result.Nodes.getNodeAs<Expr>("condition");
tools/clang/tools/extra/clang-tidy/bugprone/MisplacedOperatorInStrlenInAllocCheck.cpp 74 const Expr *Alloc = Result.Nodes.getNodeAs<CallExpr>("Alloc");
tools/clang/tools/extra/clang-tidy/bugprone/MisplacedWideningCastCheck.cpp 56 const Expr *E) {
67 Expr::EvalResult Result;
71 Expr::EvalResult Result;
190 const auto *Calc = Result.Nodes.getNodeAs<Expr>("Calc");
190 const auto *Calc = Result.Nodes.getNodeAs<Expr>("Calc");
tools/clang/tools/extra/clang-tidy/bugprone/MultipleStatementMacroCheck.cpp 69 const auto *Inner = Result.Nodes.getNodeAs<Expr>("inner");
69 const auto *Inner = Result.Nodes.getNodeAs<Expr>("inner");
tools/clang/tools/extra/clang-tidy/bugprone/NotNullTerminatedResultCheck.cpp 44 static const Expr *getDestCapacityExpr(const MatchFinder::MatchResult &Result) {
45 if (const auto *DestMalloc = Result.Nodes.getNodeAs<Expr>(DestMallocExprName))
45 if (const auto *DestMalloc = Result.Nodes.getNodeAs<Expr>(DestMallocExprName))
62 static unsigned getLength(const Expr *E,
67 Expr::EvalResult Length;
73 if (const Expr *LengthInit = LengthVD->getInit())
82 if (const Expr *StrInit = StrVD->getInit())
96 if (const auto *DestCapacityExpr = getDestCapacityExpr(Result))
118 if (Result.Nodes.getNodeAs<Expr>(UnknownLengthName))
122 getLength(Result.Nodes.getNodeAs<Expr>(WrongLengthExprName), Result))
126 getLength(Result.Nodes.getNodeAs<Expr>(LengthExprName), Result))
131 if (const Expr *Arg = StrlenCE->getArg(0)->IgnoreImpCasts())
139 static StringRef exprToStr(const Expr *E,
150 static SourceLocation exprLocEnd(const Expr *E,
169 return !Result.Nodes.getNodeAs<Expr>(UnknownDestName);
178 exprToStr(Result.Nodes.getNodeAs<Expr>(LengthExprName), Result).trim();
221 if (Result.Nodes.getNodeAs<Expr>(UnknownLengthName))
228 int SrcLength = getLength(Result.Nodes.getNodeAs<Expr>(SrcExprName), Result);
233 if (const auto *LengthExpr = Result.Nodes.getNodeAs<Expr>(LengthExprName))
233 if (const auto *LengthExpr = Result.Nodes.getNodeAs<Expr>(LengthExprName))
248 if (Result.Nodes.getNodeAs<Expr>(UnknownLengthName))
261 const Expr *DestCapacityExpr = getDestCapacityExpr(Result);
280 return !getLength(Result.Nodes.getNodeAs<Expr>(SrcExprName), Result);
290 static void lengthExprHandle(const Expr *LengthExpr,
327 const Expr *LhsExpr = BO->getLHS()->IgnoreImpCasts();
328 const Expr *RhsExpr = BO->getRHS()->IgnoreImpCasts();
367 const auto *LengthExpr = Result.Nodes.getNodeAs<Expr>(LengthExprName);
367 const auto *LengthExpr = Result.Nodes.getNodeAs<Expr>(LengthExprName);
382 const auto *Dest = Result.Nodes.getNodeAs<Expr>(DestExprName);
382 const auto *Dest = Result.Nodes.getNodeAs<Expr>(DestExprName);
401 if (const Expr *CapacityExpr = getDestCapacityExpr(Result))
414 const Expr *ArgToRemove = FunctionExpr->getArg(ArgPos);
415 const Expr *LHSArg = FunctionExpr->getArg(ArgPos - 1);
484 exprToStr(Result.Nodes.getNodeAs<Expr>(DestExprName), Result) + "[" +
485 exprToStr(Result.Nodes.getNodeAs<Expr>(LengthExprName), Result) +
517 const Expr *SimpleNode = &Node;
923 if (const auto *CastExpr = Result.Nodes.getNodeAs<Expr>(CastExprName)) {
923 if (const auto *CastExpr = Result.Nodes.getNodeAs<Expr>(CastExprName)) {
962 const Expr *FirstArgExpr = FunctionExpr->getArg(0)->IgnoreImpCasts();
963 const Expr *SecondArgExpr = FunctionExpr->getArg(1)->IgnoreImpCasts();
967 const Expr *LengthExprArg = StrlenExpr->getArg(0);
975 getLength(Result.Nodes.getNodeAs<Expr>(SrcExprName), Result);
tools/clang/tools/extra/clang-tidy/bugprone/ParentVirtualCallCheck.cpp 73 static std::string getExprAsString(const clang::Expr &E,
tools/clang/tools/extra/clang-tidy/bugprone/SizeofExpressionCheck.cpp 31 const Expr *E = Node.IgnoreParenImpCasts();
257 if (const auto *E = Result.Nodes.getNodeAs<Expr>("sizeof-constant")) {
257 if (const auto *E = Result.Nodes.getNodeAs<Expr>("sizeof-constant")) {
260 } else if (const auto *E =
261 Result.Nodes.getNodeAs<Expr>("sizeof-integer-call")) {
264 } else if (const auto *E = Result.Nodes.getNodeAs<Expr>("sizeof-this")) {
264 } else if (const auto *E = Result.Nodes.getNodeAs<Expr>("sizeof-this")) {
267 } else if (const auto *E = Result.Nodes.getNodeAs<Expr>("sizeof-charp")) {
267 } else if (const auto *E = Result.Nodes.getNodeAs<Expr>("sizeof-charp")) {
270 } else if (const auto *E =
271 Result.Nodes.getNodeAs<Expr>("sizeof-pointer-to-aggregate")) {
274 } else if (const auto *E =
275 Result.Nodes.getNodeAs<Expr>("sizeof-compare-constant")) {
278 } else if (const auto *E =
279 Result.Nodes.getNodeAs<Expr>("sizeof-comma-expr")) {
281 } else if (const auto *E =
282 Result.Nodes.getNodeAs<Expr>("sizeof-divide-expr")) {
312 } else if (const auto *E =
313 Result.Nodes.getNodeAs<Expr>("sizeof-sizeof-expr")) {
315 } else if (const auto *E =
316 Result.Nodes.getNodeAs<Expr>("sizeof-multiply-sizeof")) {
318 } else if (const auto *E =
319 Result.Nodes.getNodeAs<Expr>("sizeof-in-ptr-arithmetic-mul")) {
328 } else if (const auto *E =
329 Result.Nodes.getNodeAs<Expr>("sizeof-in-ptr-arithmetic-div")) {
tools/clang/tools/extra/clang-tidy/bugprone/StringConstructorCheck.cpp 119 if (Result.Nodes.getNodeAs<Expr>("swapped-parameter")) {
120 const Expr *P0 = E->getArg(0);
121 const Expr *P1 = E->getArg(1);
126 } else if (Result.Nodes.getNodeAs<Expr>("empty-string")) {
128 } else if (Result.Nodes.getNodeAs<Expr>("negative-length")) {
130 } else if (Result.Nodes.getNodeAs<Expr>("large-length")) {
133 } else if (Result.Nodes.getNodeAs<Expr>("literal-with-length")) {
139 } else if (const auto *Ptr = Result.Nodes.getNodeAs<Expr>("from-ptr")) {
139 } else if (const auto *Ptr = Result.Nodes.getNodeAs<Expr>("from-ptr")) {
140 Expr::EvalResult ConstPtr;
tools/clang/tools/extra/clang-tidy/bugprone/StringIntegerAssignmentCheck.cpp 53 bool isLikelyCharExpression(const Expr *E) const {
58 const auto *LHS = BinOp->getLHS()->IgnoreParenImpCasts();
59 const auto *RHS = BinOp->getRHS()->IgnoreParenImpCasts();
81 bool handleBinaryOp(clang::BinaryOperatorKind Opcode, const Expr *const LHS,
82 const Expr *const RHS) const {
108 bool isCharConstant(const Expr *E) const {
113 bool isCharValuedConstant(const Expr *E) const {
116 Expr::EvalResult EvalResult;
117 if (!E->EvaluateAsInt(EvalResult, Ctx, Expr::SE_AllowSideEffects))
123 bool isCharTyped(const Expr *E) const {
134 const auto *Argument = Result.Nodes.getNodeAs<Expr>("expr");
134 const auto *Argument = Result.Nodes.getNodeAs<Expr>("expr");
tools/clang/tools/extra/clang-tidy/bugprone/SuspiciousEnumUsageCheck.cpp 68 const Expr *InitExpr = EnumConst->getInitExpr();
81 if (const Expr *InitExpr = EnumConst->getInitExpr()) {
155 const Expr *NodeExpr, const EnumDecl *EnumDec) {
202 if (const auto *EnumExpr = Result.Nodes.getNodeAs<Expr>("enumExpr")) {
202 if (const auto *EnumExpr = Result.Nodes.getNodeAs<Expr>("enumExpr")) {
209 const auto *LhsExpr = Result.Nodes.getNodeAs<Expr>("lhsExpr");
209 const auto *LhsExpr = Result.Nodes.getNodeAs<Expr>("lhsExpr");
212 const auto *RhsExpr = Result.Nodes.getNodeAs<Expr>("rhsExpr");
212 const auto *RhsExpr = Result.Nodes.getNodeAs<Expr>("rhsExpr");
tools/clang/tools/extra/clang-tidy/bugprone/SuspiciousEnumUsageCheck.h 30 void checkSuspiciousBitmaskUsage(const Expr*, const EnumDecl*);
tools/clang/tools/extra/clang-tidy/bugprone/SuspiciousMemsetUsageCheck.cpp 79 Expr::EvalResult EVResult;
95 const Expr *FillChar = Call->getArg(1);
96 const Expr *ByteCount = Call->getArg(2);
99 Expr::EvalResult Value2;
108 Expr::EvalResult EVResult;
tools/clang/tools/extra/clang-tidy/bugprone/SuspiciousMissingCommaCheck.cpp 110 const Expr *Child = InitializerList->getInit(i)->IgnoreImpCasts();
tools/clang/tools/extra/clang-tidy/bugprone/SuspiciousStringCompareCheck.cpp 184 if (const auto *E = Result.Nodes.getNodeAs<Expr>("logical-not-comparison")) {
184 if (const auto *E = Result.Nodes.getNodeAs<Expr>("logical-not-comparison")) {
tools/clang/tools/extra/clang-tidy/bugprone/SwappedArgumentsCheck.cpp 28 static const Expr *ignoreNoOpCasts(const Expr *E) {
28 static const Expr *ignoreNoOpCasts(const Expr *E) {
53 llvm::SmallPtrSet<const Expr *, 4> UsedArgs;
55 const Expr *LHS = Call->getArg(I - 1);
56 const Expr *RHS = Call->getArg(I);
78 const Expr *LHSFrom = ignoreNoOpCasts(LHSCast->getSubExpr());
79 const Expr *RHSFrom = ignoreNoOpCasts(RHSCast->getSubExpr());
tools/clang/tools/extra/clang-tidy/bugprone/ThrowKeywordMissingCheck.cpp 41 const auto *TemporaryExpr =
42 Result.Nodes.getNodeAs<Expr>("temporary-exception-not-thrown");
tools/clang/tools/extra/clang-tidy/bugprone/TooSmallLoopVariableCheck.cpp 111 const Expr *UpperBound,
116 const Expr *RHSE = BinOperator->getRHS()->IgnoreParenImpCasts();
117 const Expr *LHSE = BinOperator->getLHS()->IgnoreParenImpCasts();
148 const auto *LoopVar = Result.Nodes.getNodeAs<Expr>(LoopVarName);
148 const auto *LoopVar = Result.Nodes.getNodeAs<Expr>(LoopVarName);
149 const auto *UpperBound =
150 Result.Nodes.getNodeAs<Expr>(LoopUpperBoundName)->IgnoreParenImpCasts();
151 const auto *LoopIncrement =
152 Result.Nodes.getNodeAs<Expr>(LoopIncrementName)->IgnoreParenImpCasts();
tools/clang/tools/extra/clang-tidy/bugprone/UnusedRaiiCheck.cpp 50 const auto *E = Result.Nodes.getNodeAs<Expr>("expr");
50 const auto *E = Result.Nodes.getNodeAs<Expr>("expr");
tools/clang/tools/extra/clang-tidy/bugprone/UseAfterMoveCheck.cpp 45 bool find(Stmt *FunctionBody, const Expr *MovingCall,
49 bool findInternal(const CFGBlock *Block, const Expr *MovingCall,
86 bool UseAfterMoveFinder::find(Stmt *FunctionBody, const Expr *MovingCall,
117 const Expr *MovingCall,
355 static void emitDiagnostic(const Expr *MovingCall, const DeclRefExpr *MoveArg,
411 const auto *MovingCall = Result.Nodes.getNodeAs<Expr>("moving-call");
411 const auto *MovingCall = Result.Nodes.getNodeAs<Expr>("moving-call");
tools/clang/tools/extra/clang-tidy/cert/ProperlySeededRandomGeneratorCheck.cpp 103 Expr::EvalResult EVResult;
tools/clang/tools/extra/clang-tidy/cert/StrToNumCheck.cpp 204 if (const Expr *Arg = Call->getArg(Idx)->IgnoreParenImpCasts()) {
tools/clang/tools/extra/clang-tidy/cert/ThrownExceptionTypeCheck.cpp 33 const auto *E = Result.Nodes.getNodeAs<Expr>("expr");
33 const auto *E = Result.Nodes.getNodeAs<Expr>("expr");
tools/clang/tools/extra/clang-tidy/cppcoreguidelines/NarrowingConversionsCheck.cpp 64 static const BuiltinType *getBuiltinType(const Expr &E) {
68 static QualType getUnqualifiedType(const Expr &E) {
72 static APValue getConstantExprValue(const ASTContext &Ctx, const Expr &E) {
83 const Expr &E, llvm::APSInt &Value) {
92 const Expr &E, llvm::APFloat &Value) {
179 const Expr &Lhs,
180 const Expr &Rhs) {
186 SourceLocation SourceLoc, const Expr &Lhs, const Expr &Rhs) {
186 SourceLocation SourceLoc, const Expr &Lhs, const Expr &Rhs) {
193 SourceLocation SourceLoc, const Expr &Lhs, const Expr &Rhs,
193 SourceLocation SourceLoc, const Expr &Lhs, const Expr &Rhs,
202 SourceLocation SourceLoc, const Expr &Lhs, const Expr &Rhs,
202 SourceLocation SourceLoc, const Expr &Lhs, const Expr &Rhs,
211 const Expr &Lhs,
212 const Expr &Rhs) {
218 const Expr &Lhs,
219 const Expr &Rhs) {
225 const ASTContext &Context, SourceLocation SourceLoc, const Expr &Lhs,
226 const Expr &Rhs) {
237 const Expr &Lhs,
238 const Expr &Rhs) {
260 const ASTContext &Context, SourceLocation SourceLoc, const Expr &Lhs,
261 const Expr &Rhs) {
270 const ASTContext &Context, SourceLocation SourceLoc, const Expr &Lhs,
271 const Expr &Rhs) {
285 const ASTContext &Context, SourceLocation SourceLoc, const Expr &Lhs,
286 const Expr &Rhs) {
310 const ASTContext &Context, SourceLocation SourceLoc, const Expr &Lhs,
311 const Expr &Rhs) {
316 const ASTContext &Context, SourceLocation SourceLoc, const Expr &Lhs,
317 const Expr &Rhs) {
327 const Expr &Lhs,
328 const Expr &Rhs) {
353 const Expr &Lhs,
354 const Expr &Rhs) {
378 const ASTContext &Context, const Expr &Lhs, const Expr &Rhs) {
378 const ASTContext &Context, const Expr &Lhs, const Expr &Rhs) {
396 const Expr &Lhs = Cast;
397 const Expr &Rhs = *Cast.getSubExpr();
427 const Expr &Lhs = *Op.getLHS();
428 const Expr &Rhs = *Op.getRHS();
tools/clang/tools/extra/clang-tidy/cppcoreguidelines/NarrowingConversionsCheck.h 32 void diagNarrowType(SourceLocation SourceLoc, const Expr &Lhs,
33 const Expr &Rhs);
35 void diagNarrowTypeToSignedInt(SourceLocation SourceLoc, const Expr &Lhs,
36 const Expr &Rhs);
38 void diagNarrowIntegerConstant(SourceLocation SourceLoc, const Expr &Lhs,
39 const Expr &Rhs, const llvm::APSInt &Value);
42 const Expr &Lhs, const Expr &Rhs,
42 const Expr &Lhs, const Expr &Rhs,
46 void diagNarrowConstant(SourceLocation SourceLoc, const Expr &Lhs,
47 const Expr &Rhs);
49 void diagConstantCast(SourceLocation SourceLoc, const Expr &Lhs,
50 const Expr &Rhs);
53 SourceLocation SourceLoc, const Expr &Lhs,
54 const Expr &Rhs);
57 const Expr &Lhs, const Expr &Rhs);
57 const Expr &Lhs, const Expr &Rhs);
60 SourceLocation SourceLoc, const Expr &Lhs,
61 const Expr &Rhs);
64 SourceLocation SourceLoc, const Expr &Lhs,
65 const Expr &Rhs);
68 SourceLocation SourceLoc, const Expr &Lhs,
69 const Expr &Rhs);
72 SourceLocation SourceLoc, const Expr &Lhs,
73 const Expr &Rhs);
76 SourceLocation SourceLoc, const Expr &Lhs,
77 const Expr &Rhs);
80 const Expr &Lhs, const Expr &Rhs);
80 const Expr &Lhs, const Expr &Rhs);
83 const Expr &Lhs, const Expr &Rhs);
83 const Expr &Lhs, const Expr &Rhs);
85 bool handleConditionalOperator(const ASTContext &Context, const Expr &Lhs,
86 const Expr &Rhs);
tools/clang/tools/extra/clang-tidy/cppcoreguidelines/OwningMemoryCheck.cpp 236 const auto *ExpectedOwner = Nodes.getNodeAs<Expr>("expected_owner_argument");
236 const auto *ExpectedOwner = Nodes.getNodeAs<Expr>("expected_owner_argument");
297 const auto *BadOwnerArgument =
298 Nodes.getNodeAs<Expr>("bad_owner_creation_argument");
tools/clang/tools/extra/clang-tidy/cppcoreguidelines/ProBoundsArrayToPointerDecayCheck.cpp 36 const Expr *E = &Node;
42 E = Parents[0].get<Expr>();
tools/clang/tools/extra/clang-tidy/cppcoreguidelines/ProBoundsConstantArrayIndexCheck.cpp 68 const auto *Matched = Result.Nodes.getNodeAs<Expr>("expr");
68 const auto *Matched = Result.Nodes.getNodeAs<Expr>("expr");
69 const auto *IndexExpr = Result.Nodes.getNodeAs<Expr>("index");
69 const auto *IndexExpr = Result.Nodes.getNodeAs<Expr>("index");
tools/clang/tools/extra/clang-tidy/cppcoreguidelines/ProBoundsPointerArithmeticCheck.cpp 55 const auto *MatchedExpr = Result.Nodes.getNodeAs<Expr>("expr");
55 const auto *MatchedExpr = Result.Nodes.getNodeAs<Expr>("expr");
tools/clang/tools/extra/clang-tidy/cppcoreguidelines/ProTypeCstyleCastCheck.cpp 77 const Expr *SubExpr =
tools/clang/tools/extra/clang-tidy/cppcoreguidelines/ProTypeVarargCheck.cpp 58 if (const auto *Matched = Result.Nodes.getNodeAs<Expr>("va_use")) {
58 if (const auto *Matched = Result.Nodes.getNodeAs<Expr>("va_use")) {
tools/clang/tools/extra/clang-tidy/cppcoreguidelines/SlicingCheck.cpp 74 const Expr &Call, const CXXRecordDecl &DerivedDecl,
103 const auto *Call = Result.Nodes.getNodeAs<Expr>("Call");
103 const auto *Call = Result.Nodes.getNodeAs<Expr>("Call");
tools/clang/tools/extra/clang-tidy/cppcoreguidelines/SlicingCheck.h 35 void DiagnoseSlicedOverriddenMethods(const Expr &call,
tools/clang/tools/extra/clang-tidy/google/AvoidCStyleCastsCheck.cpp 137 const Expr *SubExpr = CastExpr->getSubExprAsWritten()->IgnoreImpCasts();
tools/clang/tools/extra/clang-tidy/google/ExplicitMakePairCheck.cpp 54 const Expr *Arg0 = Call->getArg(0)->IgnoreParenImpCasts();
55 const Expr *Arg1 = Call->getArg(1)->IgnoreParenImpCasts();
tools/clang/tools/extra/clang-tidy/hicpp/SignedBitwiseCheck.cpp 66 const auto *SignedOperand = N.getNodeAs<Expr>("signed-operand");
66 const auto *SignedOperand = N.getNodeAs<Expr>("signed-operand");
tools/clang/tools/extra/clang-tidy/llvm/PreferIsaOrDynCastInConditionalsCheck.cpp 98 const auto *Arg = Result.Nodes.getNodeAs<Expr>("arg");
98 const auto *Arg = Result.Nodes.getNodeAs<Expr>("arg");
tools/clang/tools/extra/clang-tidy/llvm/TwineLocalCheck.cpp 35 const Expr *C = VD->getInit()->IgnoreImplicit();
tools/clang/tools/extra/clang-tidy/misc/NonCopyableObjects.cpp 57 const auto *E = Result.Nodes.getNodeAs<Expr>("expr");
57 const auto *E = Result.Nodes.getNodeAs<Expr>("expr");
tools/clang/tools/extra/clang-tidy/misc/RedundantExpressionCheck.cpp 58 static bool areEquivalentExpr(const Expr *Left, const Expr *Right) {
58 static bool areEquivalentExpr(const Expr *Left, const Expr *Right) {
70 Expr::const_child_iterator LeftIter = Left->child_begin();
71 Expr::const_child_iterator RightIter = Right->child_begin();
73 if (!areEquivalentExpr(dyn_cast<Expr>(*LeftIter),
74 dyn_cast<Expr>(*RightIter)))
336 static ast_matchers::internal::Matcher<Expr>
347 const Expr *&ConstExpr) {
349 ConstExpr = Result.Nodes.getNodeAs<Expr>(CstId);
356 const Expr *ConstExpr = nullptr;
362 static ast_matchers::internal::Matcher<Expr> matchSymbolicExpr(StringRef Id) {
371 StringRef Id, const Expr *&SymExpr) {
373 if (const auto *Node = Result.Nodes.getNodeAs<Expr>(SymId)) {
373 if (const auto *Node = Result.Nodes.getNodeAs<Expr>(SymId)) {
382 static ast_matchers::internal::Matcher<Expr>
402 const Expr *&Symbol, APSInt &Value) {
412 static ast_matchers::internal::Matcher<Expr>
495 const Expr *&OperandExpr, BinaryOperatorKind &Opcode, const Expr *&Symbol,
495 const Expr *&OperandExpr, BinaryOperatorKind &Opcode, const Expr *&Symbol,
496 APSInt &Value, const Expr *&ConstExpr) {
526 if (const auto *Arg = OverloadedOperatorExpr->getArg(1)) {
543 if (Result.Nodes.getNodeAs<Expr>(SwapId))
545 if (Result.Nodes.getNodeAs<Expr>(NegateId))
576 const Expr *&LhsConst,
577 const Expr *&RhsConst,
607 static bool areExprsFromDifferentMacros(const Expr *LhsExpr,
608 const Expr *RhsExpr,
626 static bool areExprsMacroAndNonMacro(const Expr *&LhsExpr,
627 const Expr *&RhsExpr) {
770 const Expr *LhsSymbol = nullptr, *RhsSymbol = nullptr;
847 const Expr *LhsSymbol = nullptr;
877 const Expr *Sym = nullptr, *ConstExpr = nullptr;
921 const Expr *LhsExpr = nullptr, *RhsExpr = nullptr;
922 const Expr *LhsSymbol = nullptr, *RhsSymbol = nullptr;
923 const Expr *LhsConst = nullptr, *RhsConst = nullptr;
983 const Expr *LhsConst = nullptr, *RhsConst = nullptr;
1000 const Expr *TrueExpr = CondOp->getTrueExpr();
1001 const Expr *FalseExpr = CondOp->getFalseExpr();
1038 const auto *ShiftingConst = Result.Nodes.getNodeAs<Expr>("shift-const");
1038 const auto *ShiftingConst = Result.Nodes.getNodeAs<Expr>("shift-const");
1045 const auto *AndConst = Result.Nodes.getNodeAs<Expr>("and-const");
1045 const auto *AndConst = Result.Nodes.getNodeAs<Expr>("and-const");
tools/clang/tools/extra/clang-tidy/misc/StaticAssertCheck.cpp 84 const auto *Condition = Result.Nodes.getNodeAs<Expr>("condition");
84 const auto *Condition = Result.Nodes.getNodeAs<Expr>("condition");
85 const auto *IsAlwaysFalse = Result.Nodes.getNodeAs<Expr>("isAlwaysFalse");
85 const auto *IsAlwaysFalse = Result.Nodes.getNodeAs<Expr>("isAlwaysFalse");
tools/clang/tools/extra/clang-tidy/misc/UniqueptrResetReleaseCheck.cpp 102 const auto *Right = Result.Nodes.getNodeAs<Expr>("right");
102 const auto *Right = Result.Nodes.getNodeAs<Expr>("right");
103 const auto *Left = Result.Nodes.getNodeAs<Expr>("left");
103 const auto *Left = Result.Nodes.getNodeAs<Expr>("left");
tools/clang/tools/extra/clang-tidy/misc/UnusedParametersCheck.cpp 40 const T *PrevNode, const T *Node,
40 const T *PrevNode, const T *Node,
41 const T *NextNode) {
tools/clang/tools/extra/clang-tidy/modernize/AvoidBindCheck.cpp 53 const Expr *E = C->getArg(I);
56 const auto *TE = M->GetTemporaryExpr();
tools/clang/tools/extra/clang-tidy/modernize/LoopConvertCheck.cpp 304 static const Expr *getContainerFromBeginEndCall(const Expr *Init, bool IsBegin,
304 static const Expr *getContainerFromBeginEndCall(const Expr *Init, bool IsBegin,
321 const Expr *SourceExpr = Member->getBase();
334 static const Expr *findContainer(ASTContext *Context, const Expr *BeginExpr,
334 static const Expr *findContainer(ASTContext *Context, const Expr *BeginExpr,
335 const Expr *EndExpr,
341 const Expr *BeginContainerExpr =
346 const Expr *EndContainerExpr =
373 static const ValueDecl *getReferencedVariable(const Expr *E) {
383 static bool isDirectMemberExpr(const Expr *E) {
392 static bool canBeModified(ASTContext *Context, const Expr *E) {
436 static bool containerIsConst(const Expr *ContainerExpr, bool Dereference) {
656 const Expr *ContainerExpr) {
673 const Expr *ContainerExpr,
749 LoopFixerKind FixerKind, const Expr *ContainerExpr,
841 const auto *BoundExpr = Nodes.getNodeAs<Expr>(ConditionBoundName);
841 const auto *BoundExpr = Nodes.getNodeAs<Expr>(ConditionBoundName);
847 const Expr *ContainerExpr = nullptr;
tools/clang/tools/extra/clang-tidy/modernize/LoopConvertCheck.h 45 const Expr *ContainerExpr);
49 const Expr *ContainerExpr,
60 const Expr *ContainerExpr,
tools/clang/tools/extra/clang-tidy/modernize/LoopConvertUtils.cpp 168 const Expr *digThroughConstructors(const Expr *E) {
168 const Expr *digThroughConstructors(const Expr *E) {
187 bool areSameExpr(ASTContext *Context, const Expr *First, const Expr *Second) {
187 bool areSameExpr(ASTContext *Context, const Expr *First, const Expr *Second) {
198 const DeclRefExpr *getDeclRef(const Expr *E) {
210 static bool exprReferencesVariable(const ValueDecl *Target, const Expr *E) {
219 static const Expr *getDereferenceOperand(const Expr *E) {
219 static const Expr *getDereferenceOperand(const Expr *E) {
235 const Expr *E) {
253 static bool isIndexInSubscriptExpr(const Expr *IndexExpr,
287 static bool isIndexInSubscriptExpr(ASTContext *Context, const Expr *IndexExpr,
288 const VarDecl *IndexVar, const Expr *Obj,
289 const Expr *SourceExpr, bool PermitDeref) {
297 if (const Expr *InnerObj = getDereferenceOperand(Obj->IgnoreParenImpCasts()))
358 const Expr *Init = VDecl->getInit()->IgnoreParenImpCasts();
434 const Expr *ConditionExpr) {
451 const Expr *ContainerExpr,
452 const Expr *ArrayBoundExpr,
476 void ForLoopIndexUseVisitor::addComponent(const Expr *E) {
478 const Expr *Node = E->IgnoreParenImpCasts();
540 const Expr *Base = Member->getBase();
542 const Expr *ResultExpr = Member;
690 Expr *Arr = E->getBase();
779 Expr *Init) {
tools/clang/tools/extra/clang-tidy/modernize/LoopConvertUtils.h 49 typedef llvm::SmallVector<const clang::Expr *, 16> ComponentVector;
91 void findExprComponents(const clang::Expr *SourceExpr) {
228 const Expr *Expression;
235 explicit Usage(const Expr *E)
237 Usage(const Expr *E, UsageKind Kind, SourceRange Range)
273 const Expr *digThroughConstructors(const Expr *E);
273 const Expr *digThroughConstructors(const Expr *E);
274 bool areSameExpr(ASTContext *Context, const Expr *First, const Expr *Second);
274 bool areSameExpr(ASTContext *Context, const Expr *First, const Expr *Second);
275 const DeclRefExpr *getDeclRef(const Expr *E);
287 const VarDecl *EndVar, const Expr *ContainerExpr,
288 const Expr *ArrayBoundExpr,
315 const Expr *getContainerIndexed() const { return ContainerExpr; }
347 Expr *Init);
356 void addComponent(const Expr *E);
365 const Expr *ContainerExpr;
367 const Expr *ArrayBoundExpr;
383 llvm::SmallVector<std::pair<const Expr *, llvm::FoldingSetNodeID>, 16>
tools/clang/tools/extra/clang-tidy/modernize/MakeSmartPtrCheck.cpp 260 for (const Expr *OldE = nullptr; E != OldE;) {
263 if (const Expr *Parent = Node.get<ParenExpr>()) {
281 if (const auto* ArraySize = New->getArraySize().getValueOr(nullptr)) {
294 for (const auto *Arg : CE->arguments()) {
306 if (const auto *TempExp = CEArg->getArg(0)) {
tools/clang/tools/extra/clang-tidy/modernize/ReplaceAutoPtrCheck.cpp 150 if (const auto *E =
151 Result.Nodes.getNodeAs<Expr>(AutoPtrOwnershipTransferId)) {
tools/clang/tools/extra/clang-tidy/modernize/ReplaceRandomShuffleCheck.cpp 60 const auto *MatchedArgumentThree = Result.Nodes.getNodeAs<Expr>("randomFunc");
60 const auto *MatchedArgumentThree = Result.Nodes.getNodeAs<Expr>("randomFunc");
tools/clang/tools/extra/clang-tidy/modernize/ShrinkToFitCheck.cpp 58 const auto *Container = Result.Nodes.getNodeAs<Expr>("ContainerToShrink");
58 const auto *Container = Result.Nodes.getNodeAs<Expr>("ContainerToShrink");
tools/clang/tools/extra/clang-tidy/modernize/UseAutoCheck.cpp 72 const Expr *Init = Node.getAnyInitializer();
338 const Expr *ExprInit = V->getInit();
353 const Expr *E = (*Construct->arg_begin())->IgnoreParenImpCasts();
388 llvm::function_ref<QualType(const Expr *)> GetType, StringRef Message) {
403 const auto *Expr = V->getInit()->IgnoreParenImpCasts();
tools/clang/tools/extra/clang-tidy/modernize/UseAutoCheck.h 28 llvm::function_ref<QualType(const Expr *)> GetType,
tools/clang/tools/extra/clang-tidy/modernize/UseBoolLiteralsCheck.cpp 51 const auto *Cast = Result.Nodes.getNodeAs<Expr>("cast");
51 const auto *Cast = Result.Nodes.getNodeAs<Expr>("cast");
57 const Expr *Expression = Cast ? Cast : Literal;
tools/clang/tools/extra/clang-tidy/modernize/UseDefaultMemberInitCheck.cpp 108 static bool isZero(const Expr *E) {
130 static const Expr *ignoreUnaryPlus(const Expr *E) {
130 static const Expr *ignoreUnaryPlus(const Expr *E) {
137 static const Expr *getInitializer(const Expr *E) {
137 static const Expr *getInitializer(const Expr *E) {
144 static bool sameValue(const Expr *E1, const Expr *E2) {
144 static bool sameValue(const Expr *E1, const Expr *E2) {
tools/clang/tools/extra/clang-tidy/modernize/UseEqualsDefaultCheck.cpp 50 internal::Matcher<Expr> accessToFieldInVar(const FieldDecl *Field,
tools/clang/tools/extra/clang-tidy/modernize/UseNullptrCheck.cpp 202 auto* CastSubExpr = C->getSubExpr()->IgnoreParens();
459 Expr *FirstSubExpr;
tools/clang/tools/extra/clang-tidy/mpi/BufferDerefCheck.cpp 37 SmallVector<const Expr *, 1> BufferExprs;
45 *Result.Context, Expr::NPC_ValueDependentIsNull) ||
50 const Expr *ArgExpr = CE->getArg(BufferIdx);
83 ArrayRef<const Expr *> BufferExprs) {
tools/clang/tools/extra/clang-tidy/mpi/BufferDerefCheck.h 41 ArrayRef<const Expr *> BufferExprs);
tools/clang/tools/extra/clang-tidy/mpi/TypeMismatchCheck.cpp 255 SmallVector<const Expr *, 1> BufferExprs;
264 *Result.Context, Expr::NPC_ValueDependentIsNull) ||
302 ArrayRef<const Expr *> BufferExprs,
tools/clang/tools/extra/clang-tidy/mpi/TypeMismatchCheck.h 42 ArrayRef<const Expr *> BufferExprs,
tools/clang/tools/extra/clang-tidy/performance/ImplicitConversionInLoopCheck.cpp 66 const auto *Init = Result.Nodes.getNodeAs<Expr>("init");
66 const auto *Init = Result.Nodes.getNodeAs<Expr>("init");
67 const auto *OperatorCall =
68 Result.Nodes.getNodeAs<Expr>("operator-call");
87 const Expr *OperatorCall) {
tools/clang/tools/extra/clang-tidy/performance/ImplicitConversionInLoopCheck.h 30 const Expr *OperatorCall);
tools/clang/tools/extra/clang-tidy/performance/InefficientAlgorithmCheck.cpp 91 const Expr *Arg = AlgCall->getArg(3);
114 const auto *AlgParam = Result.Nodes.getNodeAs<Expr>("AlgParam");
114 const auto *AlgParam = Result.Nodes.getNodeAs<Expr>("AlgParam");
115 const auto *IneffContExpr = Result.Nodes.getNodeAs<Expr>("IneffContExpr");
115 const auto *IneffContExpr = Result.Nodes.getNodeAs<Expr>("IneffContExpr");
tools/clang/tools/extra/clang-tidy/performance/InefficientVectorOperationCheck.cpp 65 ast_matchers::internal::Matcher<Expr> supportedContainerTypesMatcher() {
193 const auto *LoopEndExpr = Result.Nodes.getNodeAs<Expr>(LoopEndExprName);
193 const auto *LoopEndExpr = Result.Nodes.getNodeAs<Expr>(LoopEndExprName);
tools/clang/tools/extra/clang-tidy/performance/MoveConstArgCheck.cpp 22 const Expr *Arg = Call->getArg(0);
63 const auto *ReceivingExpr = Result.Nodes.getNodeAs<Expr>("receiving-expr");
63 const auto *ReceivingExpr = Result.Nodes.getNodeAs<Expr>("receiving-expr");
64 const Expr *Arg = CallMove->getArg(0);
tools/clang/tools/extra/clang-tidy/performance/NoexceptMoveConstructorCheck.cpp 71 Expr *E = ProtoType->getNoexceptExpr();
tools/clang/tools/extra/clang-tidy/readability/ContainerSizeEmptyCheck.cpp 108 const auto *Pointee = Result.Nodes.getNodeAs<Expr>("Pointee");
108 const auto *Pointee = Result.Nodes.getNodeAs<Expr>("Pointee");
109 const auto *E =
112 : (Pointee ? Pointee : Result.Nodes.getNodeAs<Expr>("STLObject"));
tools/clang/tools/extra/clang-tidy/readability/ImplicitBoolConversionCheck.cpp 108 const Expr *SubExpr = Cast->getSubExpr();
151 StringRef getEquivalentBoolLiteralForExpr(const Expr *Expression,
181 const Expr *SubExpr = Cast->getSubExpr();
tools/clang/tools/extra/clang-tidy/readability/MagicNumbersCheck.cpp 111 const Expr &ExprResult) const {
tools/clang/tools/extra/clang-tidy/readability/MagicNumbersCheck.h 34 const clang::Expr &ExprResult) const;
tools/clang/tools/extra/clang-tidy/readability/MisplacedArrayIndexCheck.cpp 38 const Expr *RHSE = ArraySubscriptE->getRHS()->IgnoreParenImpCasts();
tools/clang/tools/extra/clang-tidy/readability/NonConstParameterCheck.cpp 65 for (const auto *Arg : CE->arguments()) {
75 const Expr *Arg = CE->getArg(ArgNr++);
84 for (const auto *Arg : CE->arguments()) {
155 void NonConstParameterCheck::markCanNotBeConst(const Expr *E,
203 for (const auto *Arg : Constr->arguments()) {
205 markCanNotBeConst(cast<Expr>(M->getTemporary()), CanNotBeConst);
tools/clang/tools/extra/clang-tidy/readability/NonConstParameterCheck.h 53 void markCanNotBeConst(const Expr *E, bool CanNotBeConst);
tools/clang/tools/extra/clang-tidy/readability/RedundantSmartptrGetCheck.cpp 20 internal::Matcher<Expr> callToGet(const internal::Matcher<Decl> &OnClass) {
134 bool IsMemberExpr = Result.Nodes.getNodeAs<Expr>("memberExpr") != nullptr;
135 const auto *GetCall = Result.Nodes.getNodeAs<Expr>("redundant_get");
135 const auto *GetCall = Result.Nodes.getNodeAs<Expr>("redundant_get");
139 const auto *Smartptr = Result.Nodes.getNodeAs<Expr>("smart_pointer");
139 const auto *Smartptr = Result.Nodes.getNodeAs<Expr>("smart_pointer");
tools/clang/tools/extra/clang-tidy/readability/RedundantStringCStrCheck.cpp 28 bool needParensAfterUnaryOperator(const Expr &ExprNode) {
45 const Expr &ExprNode) {
176 const auto *Arg = Result.Nodes.getNodeAs<Expr>("arg");
176 const auto *Arg = Result.Nodes.getNodeAs<Expr>("arg");
tools/clang/tools/extra/clang-tidy/readability/RedundantStringInitCheck.cpp 61 const auto *CtorExpr = Result.Nodes.getNodeAs<Expr>("expr");
61 const auto *CtorExpr = Result.Nodes.getNodeAs<Expr>("expr");
tools/clang/tools/extra/clang-tidy/readability/SimplifyBooleanExprCheck.cpp 75 bool needsParensAfterUnaryNegation(const Expr *E) {
137 bool needsNullPtrComparison(const Expr *E) {
145 bool needsZeroComparison(const Expr *E) {
152 bool needsStaticCast(const Expr *E) {
172 const Expr *E, bool Negated,
183 const Expr *E, bool Negated) {
190 const Expr *E, bool Negated) {
195 bool Negated, const Expr *E) {
221 const Expr *LHS = nullptr;
222 const Expr *RHS = nullptr;
344 bool containsBoolLiteral(const Expr *E) {
360 const auto *LHS = Op->getLHS()->IgnoreParenImpCasts();
361 const auto *RHS = Op->getRHS()->IgnoreParenImpCasts();
364 const Expr *Other = nullptr;
635 const Expr *Condition = If->getCond();
657 getText(Result, *Result.Nodes.getNodeAs<Expr>(IfAssignVariableId));
tools/clang/tools/extra/clang-tidy/readability/StaticAccessedThroughInstanceCheck.cpp 56 const Expr *BaseExpr = MemberExpression->getBase();
tools/clang/tools/extra/clang-tidy/readability/UniqueptrDeleteReleaseCheck.cpp 41 const auto *PtrExpr = Result.Nodes.getNodeAs<Expr>("uptr");
41 const auto *PtrExpr = Result.Nodes.getNodeAs<Expr>("uptr");
42 const auto *DeleteExpr = Result.Nodes.getNodeAs<Expr>("delete");
42 const auto *DeleteExpr = Result.Nodes.getNodeAs<Expr>("delete");
tools/clang/tools/extra/clang-tidy/readability/UppercaseLiteralSuffixCheck.cpp 107 shouldReplaceLiteralSuffix(const Expr &Literal,
tools/clang/tools/extra/clang-tidy/utils/ASTUtils.cpp 27 bool IsBinaryOrTernary(const Expr *E) {
28 const Expr *E_base = E->IgnoreImpCasts();
42 bool exprHasBitFlagWithSpelling(const Expr *Flags, const SourceManager &SM,
tools/clang/tools/extra/clang-tidy/utils/ASTUtils.h 21 bool IsBinaryOrTernary(const Expr *E);
26 bool exprHasBitFlagWithSpelling(const Expr *Flags, const SourceManager &SM,
tools/clang/tools/extra/clang-tidy/utils/ExceptionAnalyzer.cpp 144 if (const auto *ThrownExpr = Throw->getSubExpr()) {
tools/clang/tools/extra/clang-tidy/utils/ExprSequence.cpp 130 const Expr *PreviousInit = nullptr;
133 if (const Expr *Init = TheVarDecl->getInit()) {
tools/clang/tools/extra/clangd/FindTarget.cpp 602 bool VisitExpr(Expr *E) {
675 if (auto *E = N.get<Expr>())
tools/clang/tools/extra/clangd/XRefs.cpp 695 if (const Expr *Init = Var->getInit()) {
696 Expr::EvalResult Result;
tools/clang/tools/extra/clangd/refactor/tweaks/ExtractFunction.cpp 234 if (Child->ASTNode.get<Expr>())
tools/clang/tools/extra/clangd/refactor/tweaks/ExtractVariable.cpp 40 const clang::Expr *getExpr() const { return Expr; }
54 const clang::Expr *Expr;
70 computeReferencedDecls(const clang::Expr *Expr) {
90 Expr = Node->ASTNode.get<clang::Expr>();
126 if (isa<clang::Expr>(Stmt))
212 llvm::dyn_cast_or_null<BinaryOperator>(N.ASTNode.get<Expr>())) {
220 N.ASTNode.get<Expr>())) {
228 const Expr *E = Child->ASTNode.get<Expr>();
228 const Expr *E = Child->ASTNode.get<Expr>();
257 if (SM.getFileID(Child->ASTNode.get<Expr>()->getExprLoc()) != F)
329 llvm::dyn_cast_or_null<CallExpr>(MaybeCall->ASTNode.get<Expr>());
332 if (CE->getCallee() != MaybeCallee.ASTNode.get<Expr>())
339 bool childExprIsStmt(const Stmt *Outer, const Expr *Inner) {
365 const Expr *E = N->ASTNode.get<Expr>();
365 const Expr *E = N->ASTNode.get<Expr>();
392 OuterImplicit.ASTNode.get<Expr>()))
407 const clang::Expr *SelectedExpr = N->ASTNode.get<clang::Expr>();
407 const clang::Expr *SelectedExpr = N->ASTNode.get<clang::Expr>();
tools/clang/tools/extra/modularize/Modularize.cpp 572 Expr *Init) {
763 Expr *Init) {
tools/clang/tools/libclang/CIndex.cpp 514 if (const Expr *E = getCursorExpr(Cursor))
765 if (Expr *Init = D->getInitExpr())
880 if (Expr *Initializer = Init->getInit())
897 if (Expr *BitWidth = D->getBitWidth())
900 if (Expr *Init = D->getInClassInitializer())
910 if (Expr *Init = D->getInit())
921 if (Expr *DefArg = D->getDefaultArgument())
1475 if (Expr *E = TAL.getSourceDeclExpression())
1480 if (Expr *E = TAL.getSourceNullPtrExpression())
1485 if (Expr *E = TAL.getSourceExpression())
1670 if (Expr *Size = TL.getSizeExpr())
1757 if (Expr *E = TL.getUnderlyingExpr())
2277 for (const auto *I : Node->varlists()) {
2288 for (const auto *E : C->private_copies()) {
2296 for (const auto *E : C->private_copies()) {
2299 for (const auto *E : C->inits()) {
2378 for (const auto *E : C->privates()) {
2381 for (const auto *E : C->inits()) {
2384 for (const auto *E : C->updates()) {
2387 for (const auto *E : C->finals()) {
2735 if (Expr *SourceExpr = E->getSourceExpr())
2832 if (const Expr *E = D->getReductionRef())
3707 auto *arg = callExpr->getArg(0);
3710 auto *subExpr = I->getSubExprAsWritten();
3796 static const ExprEvalResult* evaluateExpr(Expr *expr, CXCursor C) {
3797 Expr::EvalResult ER;
3947 static const Expr *evaluateDeclExpr(const Decl *D) {
3957 static const Expr *evaluateCompoundStmtExpr(const CompoundStmt *CS) {
3960 if (const auto *E = dyn_cast<Expr>(bodyIterator))
3960 if (const auto *E = dyn_cast<Expr>(bodyIterator))
3967 if (const Expr *E =
4356 if (Expr *Src = OVE->getSourceExpr())
4383 static SourceLocation getLocationFromExpr(const Expr *E) {
4574 const Expr *E = getCursorExpr(C);
6143 const Expr *E = getCursorExpr(C);
6577 const Expr *Callee = OCE->getCallee();
6975 const Expr *E = getCursorExpr(Cursor);
6996 const Expr *Callee = OCE->getCallee();
6998 const Expr *SubExpr = ICE->getSubExpr();
7222 const Expr *E = getCursorExpr(cursor);
tools/clang/tools/libclang/CXCursor.cpp 298 if (Expr *Src = cast<OpaqueValueExpr>(S)->getSourceExpr())
1018 const Expr *cxcursor::getCursorExpr(CXCursor Cursor) {
1019 return dyn_cast_or_null<Expr>(getCursorStmt(Cursor));
1115 const Expr *E = getCursorExpr(cursor);
1183 const Expr *E = cxcursor::getCursorExpr(C);
1210 const Expr *E = cxcursor::getCursorExpr(C);
1561 const Expr *E = nullptr;
1601 const Expr *E = nullptr;
tools/clang/tools/libclang/CXCursor.h 241 const Expr *getCursorExpr(CXCursor Cursor);
tools/clang/tools/libclang/CXIndexDataConsumer.cpp 889 const Expr *E,
tools/clang/tools/libclang/CXIndexDataConsumer.h 416 const Expr *E = nullptr,
tools/clang/unittests/AST/ASTImporterTest.cpp 742 const internal::VariadicDynCastAllOfMatcher<Expr, VAArgExpr> vaArgExpr;
1011 const internal::VariadicDynCastAllOfMatcher<Expr, CXXPseudoDestructorExpr>
2935 const internal::VariadicDynCastAllOfMatcher<Expr, DependentScopeDeclRefExpr>
tools/clang/unittests/AST/ASTTypeTraitsTest.cpp 25 return ASTNodeKind::getFromNodeKind<T>();
tools/clang/unittests/AST/EvaluateAsRValueTest.cpp 43 if (const clang::Expr *Init = VD->getInit()) {
44 clang::Expr::EvalResult Result;
tools/clang/unittests/ASTMatchers/ASTMatchersTest.h 421 if (Nodes->getNodeAs<T>(Id)) {
tools/clang/unittests/Analysis/ExprMutationAnalyzerTest.cpp 29 using ExprMatcher = internal::Matcher<Expr>;
56 const auto *const E = selectFirst<Expr>("expr", Results);
56 const auto *const E = selectFirst<Expr>("expr", Results);
65 for (const auto *E = selectFirst<Expr>("expr", Results); E != nullptr;) {
65 for (const auto *E = selectFirst<Expr>("expr", Results); E != nullptr;) {
tools/clang/unittests/Tooling/FixItTest.cpp 41 Expr *P0 = CE->getArg(0);
42 Expr *P1 = CE->getArg(1);
60 Expr *P0 = CE->getArg(0);
61 Expr *P1 = CE->getArg(1);
71 Expr *P0 = CE->getArg(0);
72 Expr *P1 = CE->getArg(1);
89 Expr *P0 = CE->getArg(0);
95 Expr *P1 = CE->getArg(1);
104 Expr *P0 = CE->getArg(0);
108 Expr *P1 = CE->getArg(1);
124 Expr *P0 = CE->getArg(0);
133 Expr *P1 = CE->getArg(1);
162 Expr *P0 = CE->getArg(0);
163 Expr *P1 = CE->getArg(1);
192 Expr *P0 = CE->getArg(0);
193 Expr *P1 = CE->getArg(1);
207 Expr *P0 = CE->getArg(0);
208 Expr *P1 = CE->getArg(1);
221 Expr *P0 = CE->getArg(0);
222 Expr *P1 = CE->getArg(1);
tools/clang/unittests/Tooling/RangeSelectorTest.cpp 136 const auto* E = Match.Result.Nodes.getNodeAs<Expr>(Call);
136 const auto* E = Match.Result.Nodes.getNodeAs<Expr>(Call);
152 const auto* E = Match.Result.Nodes.getNodeAs<Expr>(Call);
152 const auto* E = Match.Result.Nodes.getNodeAs<Expr>(Call);
tools/clang/unittests/Tooling/SourceCodeBuildersTest.cpp 69 static void testPredicate(bool (*Pred)(const Expr &), StringRef Snippet,
79 static void testPredicateOnArg(bool (*Pred)(const Expr &), StringRef Snippet,
130 llvm::Optional<std::string> (*Builder)(const Expr &, const ASTContext &),
tools/clang/unittests/Tooling/SourceCodeTest.cpp 77 Expr *P0 = CE->getArg(0);
78 Expr *P1 = CE->getArg(1);
88 Expr *P0 = CE->getArg(0);
89 Expr *P1 = CE->getArg(1);
104 Expr *P0 = CE->getArg(0);
105 Expr *P1 = CE->getArg(1);
tools/lldb/source/Plugins/ExpressionParser/Clang/ASTResultSynthesizer.cpp 223 Expr *last_expr = dyn_cast<Expr>(last_stmt);
223 Expr *last_expr = dyn_cast<Expr>(last_stmt);
tools/lldb/source/Symbol/ClangASTContext.cpp 1479 clang::Expr *const requires_clause = nullptr; // TODO: Concepts
1715 Expr *bit_width_expr = field->getBitWidth();
5939 clang::Expr *bitfield_bit_size_expr = ivar_pos->getBitWidth();
5940 clang::Expr::EvalResult result;
5999 clang::Expr *bitfield_bit_size_expr = field->getBitWidth();
6000 clang::Expr::EvalResult result;
7882 clang::Expr *bit_width = nullptr;
tools/lldb/tools/lldb-instr/Instrument.cpp 140 Expr *E = Stmt->getRetValue();
usr/include/c++/7.4.0/type_traits 215 : public __is_void_helper<typename remove_cv<_Tp>::type>::type
326 : public __is_integral_helper<typename remove_cv<_Tp>::type>::type
354 : public __is_floating_point_helper<typename remove_cv<_Tp>::type>::type
381 : public __is_pointer_helper<typename remove_cv<_Tp>::type>::type
567 : public __is_null_pointer_helper<typename remove_cv<_Tp>::type>::type
581 : public __or_<is_lvalue_reference<_Tp>,
582 is_rvalue_reference<_Tp>>::type
588 : public __or_<is_integral<_Tp>, is_floating_point<_Tp>>::type
588 : public __or_<is_integral<_Tp>, is_floating_point<_Tp>>::type
601 : public __not_<__or_<is_function<_Tp>, is_reference<_Tp>,
601 : public __not_<__or_<is_function<_Tp>, is_reference<_Tp>,
602 is_void<_Tp>>>::type
611 : public __or_<is_arithmetic<_Tp>, is_enum<_Tp>, is_pointer<_Tp>,
611 : public __or_<is_arithmetic<_Tp>, is_enum<_Tp>, is_pointer<_Tp>,
611 : public __or_<is_arithmetic<_Tp>, is_enum<_Tp>, is_pointer<_Tp>,
612 is_member_pointer<_Tp>, is_null_pointer<_Tp>>::type
612 is_member_pointer<_Tp>, is_null_pointer<_Tp>>::type
631 : public __is_member_pointer_helper<typename remove_cv<_Tp>::type>::type
638 : public __or_<is_object<_Tp>, is_reference<_Tp>>::type
638 : public __or_<is_object<_Tp>, is_reference<_Tp>>::type
777 : public __and_<is_array<_Tp>, __not_<extent<_Tp>>>
777 : public __and_<is_array<_Tp>, __not_<extent<_Tp>>>
798 typedef decltype(__test<_Tp>(0)) type;
811 remove_all_extents<_Tp>::type>::type
825 : public __is_destructible_safe<_Tp>::type
1447 : public __and_<is_destructible<_Tp>, integral_constant<bool,
1554 { typedef _Tp type; };
1558 { typedef _Tp type; };
1563 { typedef _Tp type; };
1574 remove_const<typename remove_volatile<_Tp>::type>::type type;
1580 { typedef _Tp const type; };
1629 { typedef _Tp type; };
1659 { typedef _Tp&& type; };
1955 { typedef _Tp type; };
1983 { typedef _Up type; };
1999 { typedef typename remove_reference<_Tp>::type* type; };
2003 : public __add_pointer_helper<_Tp>